- Haskell-Cafe - Haskell.org

Trouble on Travis CI with recent cabal versions
by Sven Panne 07 Mar '16

07 Mar '16

For my OpenGLRaw project, I'm using a .travis.yml generated by Herbert's https://github.com/hvr/multi-ghc-travis and the corresponding https://launchpad.net/~hvr/+archive/ubuntu/ghc PPA. Recently things broke on Travis CI, and there are a few strange things: * The cabal-install-head package seems to be based on cabal 1.23, which is older than cabal-install-1.24. Is this intended? * The OpenGLRaw package has no test suite, and this seems to be OK for cabal-install-head ( https://travis-ci.org/haskell-opengl/OpenGLRaw/jobs/114109605#L929) while cabal-install-1.24 fails in the "cabal test" step ( https://travis-ci.org/haskell-opengl/OpenGLRaw/jobs/114109606#L1022) This is a regression: I think that "cabal test" for a package without a test suite should be a no-op, at least that used to be the case. * Why does "cabal test" say "Re-configuring with test suites enabled. If this fails, please run configure manually." when "cabal configure" has already been run (including --enable-tests)? This looks like a bug... Cheers, S.

1 0

Type-level list "elem" inference
by amindfv＠gmail.com 07 Mar '16

07 Mar '16

So I've got some code that looks like: {-# LANGUAGE DataKinds, UndecidableInstances, TypeFamilies, KindSignatures, TypeOperators #-} import Data.Proxy import GHC.TypeLits type family IsSubset (as :: [Symbol]) (bs :: [Symbol]) where IsSubset as bs = IsSubsetPrime as bs bs type family IsSubsetPrime (as :: [Symbol]) bs bs' where IsSubsetPrime as '[] bs' = 'False IsSubsetPrime '[] bs bs' = 'True IsSubsetPrime (a ': as) (a ': bs) bs' = IsSubsetPrime as bs' bs' IsSubsetPrime (a ': as) (b ': bs) bs' = IsSubsetPrime (a ': as) bs bs' This lets me write functions like: foo :: (IsSubset '["foo", "bar"] args ~ 'True) => Proxy args -> Int foo args = undefined I've also got a type family: type family IsElem (a :: Symbol) (bs :: [Symbol]) where IsElem a (a ': bs) = 'True IsElem a (b ': bs) = IsElem a bs IsElem a '[] = 'False This lets me write functions like: bar :: (IsElem "foo" args ~ 'True) => Proxy args -> Int bar args = undefined The problem comes when I want to use "bar args" in the definition of "foo args" -- even though it's clear to me that ["foo","bar"] being a subset of args implies that "foo" is an element of args, I haven't written "IsElem" or "IsSubset" in a way that it's clear to the compiler. Is there a way to write IsElem and IsSubset so they "compose"? Thanks! Tom

2 1

PolyKind for Fixed and HasResolution from Data.Fixed
by Никита Тимофеев 07 Mar '16

07 Mar '16

Hi all! If we define HasResolution and Fixed like that: class HasResolution (a :: k) where resolution :: p a -> Integer newtype Fixed (a :: k) = Fixed Integer We can do something like that: instance KnownNat a => HasResolution a where resolution = natVal 2.3 :: Fixed 1 -- Timofeev N.D.

1 0

Accuracy of Data.Number.Fixed
by Lyle Kopnicky 07 Mar '16

07 Mar '16

This does not seem right to me: Prelude Data.Number.Fixed> read "4.00" :: Fixed (EpsDiv10 (EpsDiv10 Eps1)) 4.00 Prelude Data.Number.Fixed> read "4.01" :: Fixed (EpsDiv10 (EpsDiv10 Eps1)) 4.00 Prelude Data.Number.Fixed> read "4.02" :: Fixed (EpsDiv10 (EpsDiv10 Eps1)) 4.03 Prelude Data.Number.Fixed> read "4.03" :: Fixed (EpsDiv10 (EpsDiv10 Eps1)) 4.04 Prelude Data.Number.Fixed> read "4.04" :: Fixed (EpsDiv10 (EpsDiv10 Eps1)) 4.05 Maybe I am misunderstanding the purpose of this library. I guess that "two digits" of precision means that it is accurate within +/- 0.01? I think that this library is meant for doing arbitrary-precision transcendental operations. But it would not be good as a model for something like currency. It's using ratios as an internal representation, and I'm not sure what ratios it's choosing, but I think I'd choose, say, 401/100 for the "4.01" representation. I guess it's picking a slightly smaller factor than that. The non-reversibility of read/show is somewhat disconcerting. I think I prefer the Decimal library for currency. Regards, Lyle

3 4

HasCallStack - runtime costs?
by Johannes Waldmann 06 Mar '16

06 Mar '16

Dear Cafe, the new (8.*) call stack feature https://downloads.haskell.org/~ghc/8.0.1-rc2/docs/html/users_guide/glasgow_… is certainly nice for debugging during development. But how costly is it at runtime? I notice a 5 percent slowdown. That's not a problem if there's an easy way to switch this off for production (without changing the code). Related: how to make code that uses it, compile with older ghcs that don't have it. I made this hack: do not import GHC.Stack.Types, but instead {-# language CPP, MultiParamTypeClasses #-} #if (__GLASGOW_HASKELL__ < 710) {-# language NullaryTypeClasses #-} #endif module Stack ( HasCallStack ) where #if (__GLASGOW_HASKELL__ >= 800) import GHC.Stack.Types #else class HasCallStack instance HasCallStack #endif When I compile with 8.rc2, and change ">= 800" to ">= 900", I am getting the 5 percent speedup mentioned above. But does it really do what I hope it does (remove all runtime overhead that call stacks may have)? When I compile with 7.10.3, I am getting 5 .. 10 percent faster again. My code does nothing fancy (w.r.t. types and libraries), it just uses Data.IntMap heavily. And it has some class Semiring s where zero :: s one :: s plus :: HasCallStack => s -> s -> s times :: HasCallStack => s -> s -> s - J.W.

3 4

Re: [Haskell-cafe] HasCallStack - runtime costs?
by Johannes Waldmann 06 Mar '16

06 Mar '16

Thanks, Eric. > If you import a function with a HasCallStack constraint > there's no way to disable the overhead But then this means that each library should avoid these constraints? Or not, because this rightly scares away users from calling nontotal functions? > ... with a couple special rules for > building dictionaries in GHC's constraint solver. then activation of these special rules could be a compiler switch? Though it'd probably create a mess with separate compilation/linking. But switching via CPP will do the same. > class Semiring s where > plus :: HasCallStack => s -> s -> s > times :: HasCallStack => s -> s -> s > I'm curious, why do plus and times take a CallStack? because I want to (be able to) debug implementations. simplified example: {-# language ConstrainedClassMethods #-} import GHC.Stack.Types class C a where p :: a -> Int q :: HasCallStack => a -> Int instance C () where p x = error "huh" q x = error "huh" Calling q gives more information: *Main> p () *** Exception: huh CallStack (from HasCallStack): error, called at CS.hs:10:9 in main:Main *Main> q () *** Exception: huh CallStack (from HasCallStack): error, called at CS.hs:11:9 in main:Main q, called at <interactive>:44:1 in interactive:Ghci1 it, called at <interactive>:44:1 in interactive:Ghci1 I did not see another way than to change the type of the method in the class. (Which looks terrible of course.) - J.

2 1

Reducing boilerplate
by Sylvain Henry 05 Mar '16

05 Mar '16

Hi, To write FFI bindings, I use c-storable-deriving [1] to automatically derive CStorable instances for many data types (the only difference between Storable and CStorable is that CStorable provides default methods for types that have Generic instances): {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE DeriveAnyClass #-} ... data X = X { fieldStatus :: Vector 24 Word8 , fieldPadding :: Word8 } deriving (Generic, CStorable) However I also need a Storable instance, hence I have to write (the "c*" methods are provided by CStorable): instance Storable X where peek = cPeek poke = cPoke alignment = cAlignment sizeOf = cSizeOf Is there a way to automatically generate this instance for every data that has an instance of CStorable? Ideally, I would like to say once and for all: instance CStorable a => Storable a where peek = cPeek poke = cPoke alignment = cAlignment sizeOf = cSizeOf As I don't think it is currently possible, would it be sensible to add the support for automatically derived instances attached to classes (as a GHC extension)? Regards, Sylvain [1] https://hackage.haskell.org/package/c-storable-deriving

1 0

Digraphs With Text: More flexible than graphs, eager to hear from you
by Jeffrey Brown 05 Mar '16

05 Mar '16

This is a demonstration of DWT, a data structure built from and more flexible than graphs. It is powered by the *wonderful* Functional Graph Library. We beseech your involvement! DWT is open-source and actively seeking co-developers. I would happily trade any and all the privilege of determining tasks, teaching haskell or math, learning anything, and receiving obligations. We surely have much knowledge to trade! Even just a "hey why don't you do [this]!" could be precious to me. This transcript makes tiny digressions about what monads make possible. > let g = empty :: Mindmap -- g is now an empty mindmap (which is a kind of graph). > g <- pure $ insStr "frog" g -- This inserts a string into g. > -- "g <- pure $" because we use the IO monad to redefine g. > -- Now g has one thing, the word frog: > v g $ nodes g -- This views every expression in g. (0,"0: frog") > -- The 0 before the comma is a count of how many expressions refer to that expression. None do, because none yet exist. Such contexts offer many possibilities for tracking where you are (the data) and how you got there (also kind of the data, and perhaps enabling a desirable kind of removal of self|redaction). > -- The second 0 is an FGL Node, the address of the string "frog". > -- Let's add more words: > g <- pure $ insStr "moist" g > g <- pure $ insStr "springy" g > -- Now g has three words: > v g $ nodes g (0,"0: frog") (0,"1: moist") (0,"2: springy") > -- Let's indicate that moist and springy are both qualities of frogs: > -- First, we'll create a template for relationships about qualities. > g <- pure $ insTplt "_ is a quality of _" g > v g $ nodes g (0,"0: frog") (0,"1: moist") (0,"2: springy") (0,":3 _ #(is a quality of) _") > -- The template has been inserted at node 3. Its address is preceded by a : to indicate that it is a template, as opposed to the string "_ is a quality of _". (That will seem more natural in the context of how relationships are displayed.) > -- Now we'll use the template at 3 to insert two relationships among the other nodes: > -- We could have added them in a single stage: > g <- pure $ fromRight $ insRel 3 [2,0] g >>= insRel 3 [1,0] > -- insRel 3 [1,0] inserts "moist is a quality of frog". > -- insRel 3 [2,0] inserts "springy is a quality of frog". > -- Both relationships use the template at node 3, and in both the second member is frog, at node 0. > -- Since the template at 3 relates 2 expressions, each list has length two. Templates can have any arity -- for instance, "_ does _ to _" has arity 3. > -- I used the monadic bind operator (>>=) because that way I only need to escape one Either monad (using fromRight) rather than two of them, one containing the other. > -- Inserting those two relationships worked: > v g $ nodes g (2,"0: frog") (1,"1: moist") (1,"2: springy") (2,":3 _ #(is a quality of) _") (0,"4:3 2: springy ##(is a quality of) 0: frog") (0,"5:3 1: moist ##(is a quality of) 0: frog") > -- When showing a relationship, the node (integer) listed first, before the :, is it's address, and the node listed after the : is the address of its template. > -- After the first two, any other node in a relationship is the address of the symbol(s) it appears just left of. > -- Notice that now the frog is in two relationships. One of those relationships involves springy, the other involves moist. > -- The # symbols are better explained later. > -- DWT can encode meta-statements, statements about other statements. As an example, next let's encode that maybe frogs are springy because they use rubber bands. > -- First we should insert a new string and a couple new templates for relationships. > g <- pure $ insTplt "maybe _ because _" g > g <- pure $ insStr "rubber bands" g > g <- pure $ insTplt "_ uses _" g > v g $ nodes g (2,"0: frog") (1,"1: moist") (1,"2: springy") (2,":3 _ #(is a quality of) _") (0,"4:3 2: springy ##(is a quality of) 0: frog") (0,"5:3 1: moist ##(is a quality of) 0: frog") (0,":6 #maybe _ #because _") (0,"7: rubber bands") (0,":8 _ #uses _") > -- Now we can encode the subexpression that frog uses rubber bands. > g <- pure $ fr $ insRel 8 [0,7] g > v g $ nodes g (3,"0: frog") (1,"1: moist") (1,"2: springy") (2,":3 _ #(is a quality of) _") (0,"4:3 2: springy ##(is a quality of) 0: frog") (0,"5:3 1: moist ##(is a quality of) 0: frog") (0,":6 #maybe _ #because _") (1,"7: rubber bands") (1,":8 _ #uses _") (0,"9:8 0: frog ##uses 7: rubber bands") > -- From those elements, we can encode that maybe frogs are springy because they use rubber bands. > g <- pure $ fr $ insRel 6 [4,9] g > v g $ nodes g (3,"0: frog") (1,"1: moist") (1,"2: springy") (2,":3 _ #(is a quality of) _") (1,"4:3 2: springy ##(is a quality of) 0: frog") (0,"5:3 1: moist ##(is a quality of) 0: frog") (1,":6 #maybe _ #because _") (1,"7: rubber bands") (1,":8 _ #uses _") (1,"9:8 0: frog ##uses 7: rubber bands") (0,"10:6 ####maybe 4:3 2: springy ##(is a quality of) 0: frog ####because 9:8 0: frog ##uses 7: rubber bands") At last I can explain the # symbols: They indicate how fast an expression binds. In the last, at node 10, the highest-level|slowest-binding relationship is "maybe _ because _". In the first _ of the maybe-because relationship is another relationship, one that binds faster and hence has fewer # symbols, between springy and frog. The strings "springy", "frog" and "rubber bands" can be thought of as atomic, "binding" even before the first-level relationships bind. This illustrates one of DWT's advantages over graphs. In a graph, an edge cannot be a member of another edge. By contrast, in DWT a relationship can involve other relationships. -- Jeffrey Benjamin Brown

1 1

Month in Haskell Mode February 2016
by Gracjan Polak 04 Mar '16

04 Mar '16

Welcome Haskell Mode users, Haskell Mode progress report for February 2016. For previous issue see January 2015 <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-January-…> . Reddit discussion <https://www.reddit.com/r/haskell/comments/48wrru/month_in_haskell_mode_febr…> . <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-February…>What is Haskell Mode? Haskell Mode is an umbrella project for multiple Emacs tools for efficient Haskell development. Haskell Mode is an open source project developed by a group of volunteers constantly looking for contributions. For more information how to help see https://github.com/haskell/haskell-mode. <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-February…>Important developments Fontification received improvements so that it closer follows Haskell lexical rules. It was necessary to change to syntax-propertize-function available only starting with Emacs 24. There was already an improvement to how modules are shown: We also have a Twitter account: @HaskellMode <https://twitter.com/HaskellMode>. Follow us! <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-February…>Issues closed in February - Disable Indentation #90 <https://github.com/haskell/haskell-mode/issues/90> - Break point highlighting #127 <https://github.com/haskell/haskell-mode/issues/127> - Type query from up to date file information #185 <https://github.com/haskell/haskell-mode/issues/185> - haskell-stylish-on-save with Yasnippet + ghc-mod sometimes removes import list #256 <https://github.com/haskell/haskell-mode/issues/256> - haskell-indentation mode can't parse -XDoAndIfThenElse syntax #321 <https://github.com/haskell/haskell-mode/issues/321> - haskell-indentation mode sometimes can't parse multiline string literals #324 <https://github.com/haskell/haskell-mode/issues/324> - Compatibility with column-enforce-mode and long literate (latex-style) comments #331 <https://github.com/haskell/haskell-mode/issues/331> - haskell-debug parse error #399 <https://github.com/haskell/haskell-mode/issues/399> - Use preprocessor highlighting from cc-mode #521 <https://github.com/haskell/haskell-mode/issues/521> - haskell-mode-contextual-space called on zero length identifier #572 <https://github.com/haskell/haskell-mode/issues/572> - In 12.34e-56 (a single number) both . and - are colorized as operators #628 <https://github.com/haskell/haskell-mode/issues/628> - haskell-doc-mode is not asynchronous wrt ghci process, unlike eldoc-mode #649 <https://github.com/haskell/haskell-mode/issues/649> - Fix haskell-customize #667 <https://github.com/haskell/haskell-mode/issues/667> - Use easy-mmode-defmap to define all keymaps #669 <https://github.com/haskell/haskell-mode/issues/669> - Multi line string editing #727 <https://github.com/haskell/haskell-mode/issues/727> - Implement backward-sexp #759 <https://github.com/haskell/haskell-mode/issues/759> - haskell-stylish-on-save causes double saving #788 <https://github.com/haskell/haskell-mode/issues/788> - haskell-mode becomes unresponsive when adding a language pragma #820 <https://github.com/haskell/haskell-mode/issues/820> - Use flycheck to manage error and warning overlays #821 <https://github.com/haskell/haskell-mode/issues/821> - [Discussion] Separation of concerns #836 <https://github.com/haskell/haskell-mode/issues/836> - [Discussion] Perhaps tag a release? Monthly releases? #842 <https://github.com/haskell/haskell-mode/issues/842> - Split up gifcasts.el and connect dependency to specific gifs in Makefile #848 <https://github.com/haskell/haskell-mode/issues/848> - Can't press enter in haskell interactive mode #876 <https://github.com/haskell/haskell-mode/issues/876> - haskell-process-load-or-reload and haskell-interactive-switch-back #955 <https://github.com/haskell/haskell-mode/issues/955> - Font lock should support mixed Bird and Latex style literate Haskell sources #1038 <https://github.com/haskell/haskell-mode/issues/1038> - Use syntax-propertize-function #1039 <https://github.com/haskell/haskell-mode/issues/1039> - Highlight errors inside string literals #1040 <https://github.com/haskell/haskell-mode/issues/1040> - Default indentation mode ought to support and use Johan Tibell's style by default #1042 <https://github.com/haskell/haskell-mode/issues/1042> - Support spaces in project paths for haskell-process-load-file or haskell-process-load-or-reload with errors in source file #1107 <https://github.com/haskell/haskell-mode/issues/1107> - haskell-process-path-* now allowed to be lists #1112 <https://github.com/haskell/haskell-mode/issues/1112> - haskell-font-lock-symbols no longer works #1120 <https://github.com/haskell/haskell-mode/issues/1120> - Indenting data types seems broken and not configurable #1125 <https://github.com/haskell/haskell-mode/issues/1125> - Error: defcustom for ‘haskell-indent-spaces’ fails to specify type #1126 <https://github.com/haskell/haskell-mode/issues/1126> - Reconsider word breaks for haskell-cabal-mode #1146 <https://github.com/haskell/haskell-mode/issues/1146> - haskell-forward-sexp should signal scan-error at the end of list like forward-sexp #1148 <https://github.com/haskell/haskell-mode/issues/1148> - Syntax highlighting is broken for quasiquoted code #1155 <https://github.com/haskell/haskell-mode/issues/1155> - Font lock module qualification differently #1157 <https://github.com/haskell/haskell-mode/issues/1157> - HTML manual Retina resolution animated gifs #1160 <https://github.com/haskell/haskell-mode/issues/1160> - Completion function hangs in REPL in multi-line editing mode #1173 <https://github.com/haskell/haskell-mode/issues/1173> - [Discussion] Interactive mode improvements #1176 <https://github.com/haskell/haskell-mode/issues/1176> - Fontification is too inefficient #1177 <https://github.com/haskell/haskell-mode/issues/1177> <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-February…>Pull requests merged in February - Use syntax-propertize-function #1050 <https://github.com/haskell/haskell-mode/pull/1050> - Require at least Emacs 24.1 #1055 <https://github.com/haskell/haskell-mode/pull/1055> - Define haskell-package struct's slots #1083 <https://github.com/haskell/haskell-mode/pull/1083> - Detect comma style #1099 <https://github.com/haskell/haskell-mode/pull/1099> - Cleanup haskell-compat.el #1103 <https://github.com/haskell/haskell-mode/pull/1103> - Ignore stack and cabal files from hasktags #1118 <https://github.com/haskell/haskell-mode/pull/1118> - Remove suggested imports completely #1121 <https://github.com/haskell/haskell-mode/pull/1121> - Support spaces in project directories #1123 <https://github.com/haskell/haskell-mode/pull/1123> - Use condition-case-unless-debug #1124 <https://github.com/haskell/haskell-mode/pull/1124> - Fontify True/False in cabal mode #1127 <https://github.com/haskell/haskell-mode/pull/1127> - Fix snapshot build #1128 <https://github.com/haskell/haskell-mode/pull/1128> - Add indentation tests for constructor and deriving #1129 <https://github.com/haskell/haskell-mode/pull/1129> - Align data declaration contructors in indentation #1130 <https://github.com/haskell/haskell-mode/pull/1130> - Remove haskell-package.el #1132 <https://github.com/haskell/haskell-mode/pull/1132> - Docstrings and documentation for haskell-process-path-*. #1135 <https://github.com/haskell/haskell-mode/pull/1135> - Add front-sticky property to read-only text in REPL #1136 <https://github.com/haskell/haskell-mode/pull/1136> - Stylish haskell after save #1137 <https://github.com/haskell/haskell-mode/pull/1137> - Make all define-key calls use kbd #1139 <https://github.com/haskell/haskell-mode/pull/1139> - Use haskell-interactive-switch in process-load #1140 <https://github.com/haskell/haskell-mode/pull/1140> - Revert "Stylish haskell after save" #1142 <https://github.com/haskell/haskell-mode/pull/1142> - Make keymap definition more consistent #1143 <https://github.com/haskell/haskell-mode/pull/1143> - Remove some outdated code #1144 <https://github.com/haskell/haskell-mode/pull/1144> - Fix #1146 by treating . as punctuation #1149 <https://github.com/haskell/haskell-mode/pull/1149> - Add test for forward-sexp-function #1151 <https://github.com/haskell/haskell-mode/pull/1151> - Better string animation #1152 <https://github.com/haskell/haskell-mode/pull/1152> - Properly find begin of a quasiquote #1156 <https://github.com/haskell/haskell-mode/pull/1156> - Implement backward case in haskell-forward-sexp #1158 <https://github.com/haskell/haskell-mode/pull/1158> - Improve font-lock #1159 <https://github.com/haskell/haskell-mode/pull/1159> - HTML manual fixup machinery #1161 <https://github.com/haskell/haskell-mode/pull/1161> - Deriving indentatation test #1162 <https://github.com/haskell/haskell-mode/pull/1162> - Make RET in REPL create new prompt with blank input #1163 <https://github.com/haskell/haskell-mode/pull/1163> - Revert "Remove suggested imports completely" #1165 <https://github.com/haskell/haskell-mode/pull/1165> - Fix haskell-hoogle to work with buffer local var #1167 <https://github.com/haskell/haskell-mode/pull/1167> - Support simple completions in non-interactive context. Support keyword completions #1172 <https://github.com/haskell/haskell-mode/pull/1172> <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-February…>Contributors active in February Arthur Fayzrakhmanov (Артур Файзрахманов), Chris Done, Christoph Ruegge, Daniel Bergey, Daniel Selinger, Fice T, Gracjan Polak, Kamil Dworakowski, Karl Smeltzer, Mike Sperber, Sergey Vinokurov, issue-dispenser, mrBliss <https://github.com/haskell/haskell-mode/wiki/Month-in-Haskell-Mode-February…> Contributing Haskell Mode needs volunteers like any other open source project. For more information see: https://github.com/haskell/haskell-mode/wiki Also drop by our IRC channel: #haskell-emacs at irc.freenode.net. Thanks!

1 0

Function that put elements in Left or Right side of Either depending on type
by Kristoffer Føllesdal 04 Mar '16

04 Mar '16

I want a function fun :: q -> Either a b where q is of type a or b. fun shall work in the following way fun x gives Left x if x :: a fun x gives Right x if x :: b Following is a more precise description of what I want. I have function fun1 and fun2 newtype Vec k b = V [(b,k)] deriving (Eq,Ord,Show) fun1 :: (Num k) => a -> Either a (Vec k a) fun1 = Left fun2 :: (Num k) => Vec k a -> Either a (Vec k a) fun2 = Right that work in the following way {- >>> fun1 6 Left 6 >>> fun2 (V[(6,1)]) Right (V [(6,1)]) -} I want a overloaded function ‘fun' such that {- >>> fun 6 Left 6 >>> fun (V[(6,1)]) Right (V[(6,1)]) -} I have tried to use a type class to do this (see code below). But when I try >>> fun 6 I get the following error Could not deduce (Num a0) from the context (Num a, Fun a b v) bound by the inferred type for ‘it’: (Num a, Fun a b v) => Either b (v b) at <interactive>:70:1-5 The type variable ‘a0’ is ambiguous When checking that ‘it’ has the inferred type it :: forall a b (v :: * -> *). (Num a, Fun a b v) => Either b (v b) Probable cause: the inferred type is ambiguous Is the someone that have know how I can solve this? Kristoffer ——— CODE ——— {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE FlexibleInstances #-} newtype Vec k b = V [(b,k)] deriving (Eq,Ord,Show) fun1 :: (Num k) => a -> Either a (Vec k a) fun1 = Left fun2 :: (Num k) => Vec k a -> Either a (Vec k a) fun2 = Right class Fun a b v where fun :: a -> Either b (v b) instance (Num k) => Fun t t (Vec k) where fun = fun1 instance (Num k) => Fun (Vec k t) t (Vec k) where fun = fun2

4 3