December 2015 - Haskell-Cafe

Reasoning about performance
by Joachim Durchholz 05 Dec '15

05 Dec '15

Hi all, is there an easy-to read introductory paper on reasoning about performance in Haskell? Stuff like big-Oh space and time complexity of a function. What I'm mostly after is how to organize complexity reasoning given non-strict evaluation. In that situation, a function's complexity depends on what subexpressions of the parameters have already been evaluated, so you get rather complicated conditional formulae, and you also need to somehow express what parts of a passed-in parameter may get evaluated under what conditions. Is there even a good notation for that kind of stuff? Is there advice on how to organize the code to make performance formulae manageable? Example: Performance of length xs Turns out it is the number of items in xs, plus whatever you need to evaluate the list spine, as far as the list spine elements have not yet been evaluated (but you do not need to evaluate the list items). I have no idea how to even write that down. What notation to use so one can formally reason about it. Any pointers? Regards, Jo

4 6

ANN: stack-0.1.10.0
by Emanuel Borsboom 05 Dec '15

05 Dec '15

Release notes: - The Stack home page is now at haskellstack.org, which shows the documentation rendered by readthedocs.org. Note: this has necessitated some changes to the links in the documentation’s markdown source code, so please check the links on the website before submitting a PR to fix them. - The locations of the Ubuntu <http://docs.haskellstack.org/en/stable/install_and_upgrade.html#ubuntu> and Debian <http://docs.haskellstack.org/en/stable/install_and_upgrade.html#debian> package repositories have changed to have correct URL semantics according to Debian’s guidelines #1378 <https://github.com/commercialhaskell/stack/issues/1378>. The old locations will continue to work for some months, but we suggest that you adjust your /etc/apt/sources.list.d/fpco.list to the new location to avoid future disruption. - openSUSE and SUSE Linux Enterprise <http://docs.haskellstack.org/en/stable/install_and_upgrade.html#opensuse-su…> packages are now available, thanks to @mimi1vx <https://github.com/mimi1vx>. Note: there will be some lag before these pick up new versions, as they are based on Stackage LTS. Major changes: - Support for building inside a Nix-shell providing system dependencies #1285 <https://github.com/commercialhaskell/stack/pull/1285> - Add optional GPG signing on stack upload --sign or with stack sig sign ... Other enhancements: - Print latest applicable version of packages on conflicts #508 <https://github.com/commercialhaskell/stack/issues/508> - Support for packages located in Mercurial repositories #1397 <https://github.com/commercialhaskell/stack/issues/1397> - Only run benchmarks specified as build targets #1412 <https://github.com/commercialhaskell/stack/issues/1412> - Support git-style executable fall-through (stack something executes stack-something if present) #1433 <https://github.com/commercialhaskell/stack/issues/1433> - GHCi now loads intermediate dependencies #584 <https://github.com/commercialhaskell/stack/issues/584> - --work-dir option for overriding .stack-work #1178 <https://github.com/commercialhaskell/stack/issues/1178> - Support detailed-0.9 tests #1429 <https://github.com/commercialhaskell/stack/issues/1429> - Docker: improved POSIX signal proxying to containers #547 <https://github.com/commercialhaskell/stack/issues/547> Bug fixes: - Show absolute paths in error messages in multi-package builds #1348 <https://github.com/commercialhaskell/stack/issues/1348> - Docker-built binaries and libraries in different path #911 <https://github.com/commercialhaskell/stack/issues/911> #1367 <https://github.com/commercialhaskell/stack/issues/1367> - Docker: --resolver argument didn’t effect selected image tag - GHCi: Spaces in filepaths caused module loading issues #1401 <https://github.com/commercialhaskell/stack/issues/1401> - GHCi: cpp-options in cabal files weren’t used #1419 <https://github.com/commercialhaskell/stack/issues/1419> - Benchmarks couldn’t be run independently of eachother #1412 <https://github.com/commercialhaskell/stack/issues/1412> - Send output of building setup to stderr #1410 <https://github.com/commercialhaskell/stack/issues/1410>

2 1

Creating an instance of the Show Typeclass for a datatype
by Murilo Winter 03 Dec '15

03 Dec '15

Hello, As part of my exercise, I have to create an instance of the show typeclass for a given data type defined as: 1. *type *stat *= (*String*, Int)* *If* it was a data type, like: 1. data TrafficLight = Red | Yellow | Green It would be as simple as doing: 1. instance Show TrafficLight where 2. show Red = "Red light" 3. show Yellow = "Yellow light" 4. show Green = "Green light" However, I do not know how to declare the instance for a type, and then how to access its elements (String and Int). This is what I have so far, which does not work: 1. instance Show Stat where 2. show stat(a,b) = a instance Show Stat where show stat(a b) = b (imagine, for example, I desire to write" the value of "String" is "Int"). Thanks,

3 2

Yet Another Named Record
by Dmitry Olshansky 03 Dec '15

03 Dec '15

Hello, cafe! I made a small library https://github.com/odr/pers. It is my attempt for Named Record problem. There is no TH, just TF, Symbols and so on. With this library one can now: * Construct record sequentially (record is balanced tuple-based tree): type T = "a":>Int +> "b":>String +> "c":>Maybe Int rec = V 5 +> V "b" +> V (Just 3) :: T * Get Lens' for fields or record (group of fields) with O(k*log n) access: lb = fieldLens (Proxy :: "b":>String) :: Lens' T String lca = recLens :: Lens' T ("c:>Maybe Int +> "a":>Int) Note that recLens is Projection! * Lift all fields into Functor: type LT = Lifted Maybe T -- LT == "a":>Maybe Int +> "b":>Maybe String +> "c":>Maybe (Maybe Int) If all fields has Default instances, record has it also. It is the case for Lifted Maybe T. * Convert from and to Map of fields (using PersistField and PersistValue from persistent package) m = M.fromList [ (someSymbolVal "a", toPersistValue 1) , (someSymbolVal "b", toPersistValue "xx") -- value for "c" is optional ] recEither = mapToRec (Proxy :: Proxy T) m :: Either [SomeSymbol] T m' = fmap toMap recEither I wonder: - Are there similar attempts? - Is it interesting? I suppose it could be used as basis for Persistent (instead of TH). Is it? Other application? - What other features you want to add here? Best regards, Dmitry Olshansky

1 0

[ANNOUNCE] An Argh! interpreter in wxHaskell
by Henk-Jan van Tuyl 03 Dec '15

03 Dec '15

L.S., I just updated and cabalized arghwxhaskell (which I found on SourceForge) and put it on Hackage. arghwxhaskell is an interpreter for the Argh! programming language in wxHaskell. Argh! is an esoteric programming language created by Sascha Wilde. Wiki page: https://wiki.haskell.org/Argh! Package address: https://hackage.haskell.org/package/arghwxhaskell Regards, Henk-Jan van Tuyl -- Folding@home What if you could share your unused computer power to help find a cure? In just 5 minutes you can join the world's biggest networked computer and get us closer sooner. Watch the video. http://folding.stanford.edu/ http://Van.Tuyl.eu/ http://members.chello.nl/hjgtuyl/tourdemonad.html Haskell programming --

1 0

[ANNOUNCE] Haskell DBMS: Project:M36
by A.M. 02 Dec '15

02 Dec '15

Hello, Project:M36 is an open-source, relational algebra engine database management system written in Haskell. When used as a backend with other Haskell frameworks such as yesod, Project:M36 completes a fully-Haskell application stack. https://github.com/agentm/project-m36 Project:M36 adheres strongly to the relational algebra principles laid out by Chris Date in his books and, thus, includes a TutorialD interactive interpreter for learning about the relational algebra. Thus, Project:M36 does not suffer from the typical type-system impedance mismatch or SQL inconsistencies common in ORMs. Of particular interest to Haskellers is the existentially-quantified value type which allows any Haskell data type adhering to a set of basic typeclasses to be used directly as a database value. This feature includes creating database functions to operate directly on these values. In addition, the transaction model is similar to git: instead of continually contending for the "latest committed" state, the DBMS maintains a transaction graph which allows for branching and time travel to past commits. Naturally, through the use of immutable data structures, Project:M36 opens the door for parallelization of every query. Project:M36 includes two native Haskell interfacing libraries: a) a driver for the "persistent" library and b) a client library which allows direct access to the relational algebra DSLs. Thanks for looking at Project:M36! Best regards, Team Project:M36

3 3

[ANNOUNCE] Haskell DBMS: Project:M36
by A.M. 02 Dec '15

02 Dec '15

Hello, Project:M36 is an open-source, relational algebra engine database management system written in Haskell. When used as a backend with other Haskell frameworks such as yesod, Project:M36 completes a fully-Haskell application stack. https://github.com/agentm/project-m36 Project:M36 adheres strongly to the relational algebra principles laid out by Chris Date in his books and, thus, includes a TutorialD interactive interpreter for learning about the relational algebra. Thus, Project:M36 does not suffer from the typical type-system impedance mismatch or SQL inconsistencies common in ORMs. Of particular interest to Haskellers is the existentially-quantified value type which allows any Haskell data type adhering to a set of basic typeclasses to be used directly as a database value. This feature includes creating database functions to operate directly on these values. In addition, the transaction model is similar to git: instead of continually contending for the "latest committed" state, the DBMS maintains a transaction graph which allows for branching and time travel to past commits. Naturally, through the use of immutable data structures, Project:M36 opens the door for parallelization of every query. Project:M36 includes two native Haskell interfacing libraries: a) a driver for the "persistent" library and b) a client library which allows direct access to the relational algebra DSLs. Thanks for looking at Project:M36! Best regards, Team Project:M36

1 0

Month (and a bit) in haskell-ide-engine November 2015
by Alan & Kim Zimmerman 02 Dec '15

02 Dec '15

Welcome Haskell IDE Engine (future) users, Haskell IDE Engine progress report for November 2015. What is Haskell IDE Engine? Not an IDE. It is a common point to join together the effort of integrating tools into an IDE and the effort of writing tools for an IDE, by providing an API in the middle that each of these parties can work from and to. Important developments The first commit to this project took place on 22 October. In a little over a month we have had 290 commits, 116 PRs, and 114 issues. We have 14 contributors, 16 forks, 155 stars and 36 watchers. So it is safe to say we are actively working on the project. At this point we have an initial implementation of the architecture, which allows for different front end transport implementations to interface with the IDE. The current supported transports are JSON over stdio and JSON over HTTP. The architecture allows for other data encodings or interface protocols, so long as the hie side can read and write to TChans. We have a PluginDescriptor type which captures information about a given plugin, which is loaded into the main dispatcher in a namespace per plugin. The commands exposed by a plugin can run in synchronous or async mode, if they are long running, or must coordinate with backend infrastructure. The initial plugins under development provide access to - ghc-mod - HaRe - base plugin, allowing plugin introspection - example plugin A ghci-ng plugin is on hold pending the Remote GHCi work Simon Marlow is doing. We have initial integrations to emacs, and to leksah. Current project focus The current project focus is on getting our collective heads straight on what actually needs to be done, and to provide working integrations to at least 2 IDEs to get a better feel for what is needed. Both of these are well in hand, and if anyone would like to join in the discussion happens via the github issue tracker and docs section of the project, as well as IRC at #haskell-ide-engine on freenode. Issues closed in November - Do plugins the same way as GHC #1 <https://github.com/haskell/haskell-ide-engine/issues/1> - Use Idris's protocol? #3 <https://github.com/haskell/haskell-ide-engine/issues/3> - What would the smallest useful haskell-ide look like #4 <https://github.com/haskell/haskell-ide-engine/issues/4> - Loose comments from editor (emacs) perspective #5 <https://github.com/haskell/haskell-ide-engine/issues/5> - Name of project module hierarchy root question #9 <https://github.com/haskell/haskell-ide-engine/issues/9> - Proposition: setup the same label and milestones system as in stack repo #22 <https://github.com/haskell/haskell-ide-engine/issues/22> - The command "./travis_long stack +RTS -N2 -RTS build --test --pedantic" exited with 1 #28 <https://github.com/haskell/haskell-ide-engine/issues/28> - Travis build should be deterministic #30 <https://github.com/haskell/haskell-ide-engine/issues/30> - HIE should start web server only on demand #31 <https://github.com/haskell/haskell-ide-engine/issues/31> - Make all ToJSON instances clearly visible #32 <https://github.com/haskell/haskell-ide-engine/issues/32> - make jsonHttpListener only start via a CLI flag #33 <https://github.com/haskell/haskell-ide-engine/issues/33> - Add the balance of commands to the HaRe plugin #36 <https://github.com/haskell/haskell-ide-engine/issues/36> - Extend the dispatcher to validate commands before calling worker #37 <https://github.com/haskell/haskell-ide-engine/issues/37> - Decide on package name for the plugin API / plugin packages #39 <https://github.com/haskell/haskell-ide-engine/issues/39> - Remove Context from IdeRequest #40 <https://github.com/haskell/haskell-ide-engine/issues/40> - Consume invalid input #43 <https://github.com/haskell/haskell-ide-engine/issues/43> - Encourage stateless programming style #45 <https://github.com/haskell/haskell-ide-engine/issues/45> - Worker function parameter passing #54 <https://github.com/haskell/haskell-ide-engine/issues/54> - Bring in async processing #67 <https://github.com/haskell/haskell-ide-engine/issues/67> - Define Emacs menu #68 <https://github.com/haskell/haskell-ide-engine/issues/68> - Add references to hsimport, hlint-refactor, haskdogs, etc. #84 <https://github.com/haskell/haskell-ide-engine/issues/84> - struggling with ghci-ng #86 <https://github.com/haskell/haskell-ide-engine/issues/86> - Different behavior between launch stack exec hie and hie directly #87 <https://github.com/haskell/haskell-ide-engine/issues/87> - PluginDescriptor should not be serialisable #92 <https://github.com/haskell/haskell-ide-engine/issues/92> - Add user visible info to PluginDescriptor #98 <https://github.com/haskell/haskell-ide-engine/issues/98> - Consider switching back to aeson-generated json serialization? #109 <https://github.com/haskell/haskell-ide-engine/issues/109> Pull requests merged in November - Fix badges #15 <https://github.com/haskell/haskell-ide-engine/pull/15> - Add argon to Tools #17 <https://github.com/haskell/haskell-ide-engine/pull/17> - (RFC) [list of tools] add more tools, add links, add short descriptions, group tools #18 <https://github.com/haskell/haskell-ide-engine/pull/18> - fixed typo #21 <https://github.com/haskell/haskell-ide-engine/pull/21> - [RFC] New readme for the project #23 <https://github.com/haskell/haskell-ide-engine/pull/23> - Fix spelling of ‘supersede’ in README #24 <https://github.com/haskell/haskell-ide-engine/pull/24> - Fix minor typos #26 <https://github.com/haskell/haskell-ide-engine/pull/26> - Add Emacs process communication layer #27 <https://github.com/haskell/haskell-ide-engine/pull/27> - Improve wire protocol #34 <https://github.com/haskell/haskell-ide-engine/pull/34> - Handwrite ToJSON instances, fix #32 #35 <https://github.com/haskell/haskell-ide-engine/pull/35> - Introduce cmdFileExtensions for the CommandDescriptor #41 <https://github.com/haskell/haskell-ide-engine/pull/41> - Make web interface optional and port configurable #42 <https://github.com/haskell/haskell-ide-engine/pull/42> - Remove Context, simplifying IdeRequest #44 <https://github.com/haskell/haskell-ide-engine/pull/44> - Implement testing framework for Emacs (plus some fixes) #46 <https://github.com/haskell/haskell-ide-engine/pull/46> - Remove state cwd #47 <https://github.com/haskell/haskell-ide-engine/pull/47> - Dispatcher validation #51 <https://github.com/haskell/haskell-ide-engine/pull/51> - Improve console #53 <https://github.com/haskell/haskell-ide-engine/pull/53> - Error structure with code #55 <https://github.com/haskell/haskell-ide-engine/pull/55> - Use a GADT parametrized by param type, fixes #54 #56 <https://github.com/haskell/haskell-ide-engine/pull/56> - Ghcmod commands #57 <https://github.com/haskell/haskell-ide-engine/pull/57> - Expect json input separated by STX, fix #43 #59 <https://github.com/haskell/haskell-ide-engine/pull/59> - fixed typo ParamDescription #60 <https://github.com/haskell/haskell-ide-engine/pull/60> - Add the rest of the commands to HaRe plugin #62 <https://github.com/haskell/haskell-ide-engine/pull/62> - Short cut sleeping when result is available #63 <https://github.com/haskell/haskell-ide-engine/pull/63> - Typed responses #64 <https://github.com/haskell/haskell-ide-engine/pull/64> - Enrich plugins call #65 <https://github.com/haskell/haskell-ide-engine/pull/65> - Implement STX #69 <https://github.com/haskell/haskell-ide-engine/pull/69> - Fall back to emacs if there is no emacs24 binary #70 <https://github.com/haskell/haskell-ide-engine/pull/70> - Async dispatch #72 <https://github.com/haskell/haskell-ide-engine/pull/72> - Remove invalid input even if not handled #73 <https://github.com/haskell/haskell-ide-engine/pull/73> - Handle end-of-file #74 <https://github.com/haskell/haskell-ide-engine/pull/74> - Properly handle STX delimited message #75 <https://github.com/haskell/haskell-ide-engine/pull/75> - [WIP] Initial stab at hie-mode #76 <https://github.com/haskell/haskell-ide-engine/pull/76> - Rename sub-packages to be hie-* #77 <https://github.com/haskell/haskell-ide-engine/pull/77> - added fast-tags #80 <https://github.com/haskell/haskell-ide-engine/pull/80> - Simplify json #85 <https://github.com/haskell/haskell-ide-engine/pull/85> - Support commands that only require a context #88 <https://github.com/haskell/haskell-ide-engine/pull/88> - Add plugin name to commandDetail response #90 <https://github.com/haskell/haskell-ide-engine/pull/90> - Ghc mod dir #91 <https://github.com/haskell/haskell-ide-engine/pull/91> - PluginDescriptor no longer serialisable. #93 <https://github.com/haskell/haskell-ide-engine/pull/93> - Adapt elisp to plugins response changes #94 <https://github.com/haskell/haskell-ide-engine/pull/94> - Json enhancements #96 <https://github.com/haskell/haskell-ide-engine/pull/96> - Use hierarchical menus instead of a flat one #97 <https://github.com/haskell/haskell-ide-engine/pull/97> - Create elisp functions for all commands #99 <https://github.com/haskell/haskell-ide-engine/pull/99> - Rename haskell-ide-engine to hie #100 <https://github.com/haskell/haskell-ide-engine/pull/100> - Update irc channel for travis #101 <https://github.com/haskell/haskell-ide-engine/pull/101> - Insert dash between plugin and command name #102 <https://github.com/haskell/haskell-ide-engine/pull/102> - Use dash.el #103 <https://github.com/haskell/haskell-ide-engine/pull/103> - nicer parameters and command return type #105 <https://github.com/haskell/haskell-ide-engine/pull/105> - Install dash.el for tests and require it #106 <https://github.com/haskell/haskell-ide-engine/pull/106> - docs: mention apply-refact, hsimport, haskdogs #110 <https://github.com/haskell/haskell-ide-engine/pull/110> - add ShortName and Overview to PluginDescriptor #111 <https://github.com/haskell/haskell-ide-engine/pull/111> - Extract the first type of a type info response #113 <https://github.com/haskell/haskell-ide-engine/pull/113> Contributors active in November Aaron Wolf, Alan Zimmerman, Daniel Bergey, Daniel Gröber, Gracjan Polak, JP Moresmau, Jochen Görtler, Joe Hillenbrand, Justin Wood, Michael Sloan, Moritz Kiefer, Rory O’Kane, Rémi Vion, jpmoresmau Thanks A special thanks to Gracjan Polak for running his report scripts on this repo. Contributing Haskell IDE Engine needs volunteers like any other open source project. For more information see: https://github.com/haskell/haskell-ide-engine Also drop by our IRC channel: #haskell-ide-engine at irc.freenode.net. Thanks! Alan

1 0

A new case for the pointed functor class
by roconnor＠theorem.ca 02 Dec '15

02 Dec '15

>From <http://r6research.livejournal.com/28338.html>: There has been some debate for some time as to whether there should be a superclass for Applicative with just the pure function should exist: -- Natural law: -- fmap f . pure = pure . f class Functor f => Pointed f where pure :: a -> f a The charge laid against this class is that there are no laws for this single function beyond the single law that is naturally implied. Compare this to a more reasonable class -- Natural laws: -- distRight . right . fmap f = fmap (right f) . distRight -- distRight . left f = fmap (left f) . distRight -- -- Other laws: -- 1. either absurd (fmap Right) = distRight :: Either Void (f a) -> f (Either Void a) -- 2. fmap assocL . distRight . right distRight . assocR = distRight :: Either (Either a b) (f c) -> f (Either (Either a b) c) -- where -- assocL :: Either a (Either b c) -> Either (Either a b) c -- assocL (Left a) = Left (Left a) -- assocL (Right (Left a)) = Left (Right a) -- assocL (Right (Right a)) = Right a -- assocR :: Either (Either a b) c -> Either a (Either b c) -- assocR (Left (Left a)) = Left a -- assocR (Left (Right a)) = Right (Left a) -- assocR (Right a) = Right (Right a) class Functor f => StrongSum f where distRight :: Either a (f b) -> f (Either a b) distLeft :: Either (f a) b -> f (Either a b) distLeft = fmap switch . distRight . switch where switch :: Either a b -> Either b a switch = Right ||| Left StrongSum is a honest class with two additional real laws in addition to its natural laws. No one would object to creating and using such a class. What if I told you that Pointed and StrongSum are in fact the same class? class Functor f => Pointed f where pure :: a -> f a pure = fmap (id ||| absurd) . distRight . Left distRight : Either a (f b) -> f (Either a b) distRight = either (fmap Left . pure) (fmap Right) Theorem 1. If we define pure, then the distRight automatically satisfies the 2 required laws. Proof. Law 1: either absurd (fmap Right) = { extensionality of absurd } either (fmap Left . pure) (fmap Right) = { definition in terms of pure } distRight :: Either Void (f a) -> f (Either Void a) Law 2: fmap assocL . either (fmap Left . pure) (fmap Right) . right (either (fmap Left . pure) (fmap Right)) . assocR = either (fmap Left . pure) (fmap Right) case 1: Right x fmap assocL . either (fmap Left . pure) (fmap Right) . right (either (fmap Left . pure) (fmap Right)) . assocR $ Right x = fmap assocL . either (fmap Left . pure) (fmap Right) . right (either (fmap Left . pure) (fmap Right)) $ Right (Right x) = fmap assocL . either (fmap Left . pure) (fmap Right) $ Right (either (fmap Left . pure) (fmap Right) (Right x)) = fmap assocL . either (fmap Left . pure) (fmap Right) $ Right (fmap Right x) = fmap assocL $ fmap Right (fmap Right x) = fmap (assocL . Right . Right) x = fmap Right x = either (fmap Left . pure) (fmap Right) $ Right x case 2: Left (Right x) fmap assocL . either (fmap Left . pure) (fmap Right) . right (either (fmap Left . pure) (fmap Right)) . assocR $ Left (Right x) = fmap assocL . either (fmap Left . pure) (fmap Right) . right (either (fmap Left . pure) (fmap Right)) $ Right (Left x) = fmap assocL . either (fmap Left . pure) (fmap Right) $ Right (either (fmap Left . pure) (fmap Right) (Left x)) = fmap assocL . either (fmap Left . pure) (fmap Right) $ Right (fmap Left (pure x)) = fmap assocL $ fmap Right (fmap Left (pure x)) = fmap (assocL . Right . Left) (pure x) = fmap (Left . Right) (pure x) = fmap Left . fmap Right . pure $ x = fmap Left . pure . Right $ x = fmap Left . pure $ Right x = either (fmap Left . pure) (fmap Right) $ Left (Right x) case 3: Left (Left x) fmap assocL . either (fmap Left . pure) (fmap Right) . right (either (fmap Left . pure) (fmap Right)) . assocR $ Left (Left x) = fmap assocL . either (fmap Left . pure) (fmap Right) . right (either (fmap Left . pure) (fmap Right)) $ Left x = fmap assocL . either (fmap Left . pure) (fmap Right) $ Left x = fmap assocL . fmap Left . pure $ x = fmap (assocL . Left) . pure $ x = fmap (Left . Left) . pure $ x = fmap Left . fmap Left . pure $ x = fmap Left . pure . Left $ x = fmap Left . pure $ Left x = either (fmap Left . pure) (fmap Right) $ Left (Left x) Theorem 2. If we define pure, then pure = fmap (id ||| absurd) . distRight . Left where distRight = either (fmap Left . pure) (fmap Right) Proof. fmap (id ||| absurd) . distRight . Left = fmap (id ||| absurd) . either (fmap Left . pure) (fmap Right) . Left = fmap (id ||| absurd) . fmap Left . pure = fmap ((id ||| absurd) . Left) . pure = fmap id . pure = pure Theorem 3. If we define distRight such that distRight satisfies its two laws then distRight = either (fmap Left . pure) (fmap Right) where pure = fmap (id ||| absurd) . distRight . Left. Proof. either (fmap Left . fmap (id ||| absurd) . distRight . Left) (fmap Right) = distRight case 1: Left x either (fmap Left . fmap (id ||| absurd) . distRight . Left) (fmap Right) $ Left x = fmap Left . fmap (id ||| absurd) . distRight $ Left x = fmap (Left . (id ||| absurd)) $ distRight (Left x) = fmap (Left ||| (Left . absurd)) $ distRight (Left x) = fmap (Left ||| absurd) $ distRight (Left x) = { extensionality of absurd } fmap (Left ||| Right) $ distRight (Left x) = fmap id $ distRight (Left x) = distRight (Left x) case 2: Right x either (fmap Left . fmap (id ||| absurd) . distRight . Left) (fmap Right) $ Right x = fmap Right x = fmap (left absurd . Right) x = fmap (left absurd) $ fmap Right x = fmap (left absurd) . either absurd (fmap Right) $ Right x = { Law 1 for distRight } fmap (left absurd) . distRight $ Right x = { Natural law for distRight } distRight . left absurd $ Right x = distRight $ Right x Interestingly we only ever used the first law for distRight. By composing these proofs together we should be able to show that the second law for distRight holds whenever the first law does. In conclusion we have seen that the StrongSum class and the Pointed class are equivalent classes. The pure function contains the heart of what a law abiding distRight function is, such that whenever we have a law abiding distRight function it can be written in terms of pure and every instance of pure yields a law abiding distRight function. Given that I think people would welcome a StrongSum class, it only makes sense to equally welcome the Pointed class. -- Russell O'Connor <http://r6.ca/> ``All talk about `theft,''' the general counsel of the American Graphophone Company wrote, ``is the merest claptrap, for there exists no property in ideas musical, literary or artistic, except as defined by statute.''

2 1

Monadic function fails as Nothing in Maybe context but as Exception in Either context.
by Jeffrey Brown 01 Dec '15

01 Dec '15

I've written a monadic function which in a Maybe context produces a Nothing when it fails (as intended), but in an Either context produces an Exception rather than a Left. Here's a tiny demonstration. "tinyGraph" below has one Node, 0, with the label "dog". If I try to change the label at Node 0 to "cat", it works. If I try to change the label at Node 1 to "cat", it fails, because Node 1 is not in the graph. type MyGraph = Gr String String tinyGraph = mkGraph [(0, "dog")] [] :: MyGraph maybeSucceed = replaceStringAtNodeM tinyGraph 0 "cat" :: Maybe MyGraph -- == Just (mkGraph [(0,"cat")] []) maybeFail = replaceStringAtNodeM tinyGraph 1 "cat" :: Maybe MyGraph -- == Nothing eitherSucceed = replaceStringAtNodeM tinyGraph 0 "cat" :: Either String MyGraph -- == Right (mkGraph [(0,"cat")] []) eitherFail = replaceStringAtNodeM tinyGraph 1 "cat" :: Either String MyGraph -- *** Exception: Node not in Graph Here's the code: import Data.Graph.Inductive -- FGL, the Functional Graph Library gelemM :: (Monad m) => MyGraph -> Node -> m () gelemM g n = if gelem n g -- FGL's gelem function returns then return () -- True if the node is in the graph else fail "Node not in Graph" -- False otherwise replaceStringAtNode :: MyGraph -> Node -> String -> MyGraph replaceStringAtNode g n e = let (Just (a,b,c,d),g') = match n g in (a,b,e,d) & g' replaceStringAtNodeM :: (Monad m) => MyGraph -> Node -> String -> m MyGraph replaceStringAtNodeM g n s = do gelemM g n return $ replaceStringAtNode g n s -- if evaluated, the pattern match in replaceStringAtNode must succeed, -- because gelemM catches the case where n is not in the graph [1] https://github.com/JeffreyBenjaminBrown/digraphs-with-text/blob/master/test… -- Jeffrey Benjamin Brown

5 10