- Haskell-Cafe - Haskell.org

[Job] Cross Compass is currently hiring Haskell developers
by Ramin Honary 27 Nov '18

27 Nov '18

[Cross Compass](https://www.xcompass.com/en/) is a data science and machine learning consultancy located in Tokyo, Japan. Most of the work is focused on solving problems for clients by making creative use of their data. We currently have a small team of Haskellers working on a deep learning framework implemented in Haskell. We plan to use this framework multiple ways. For example, we have created a web platform for the manufacturing industry to make it easy to generate anomaly detection models for use in a factory. We are hiring Haskell programmers to help create this framework. We are mainly looking for people skilled in either web programming or machine learning. ### The ideal candidate would be similar to the following: - Passionate about functional programming, type-driven development, and modern artificial intelligence, especially deep learning. - Have experience with machine learning/deep learning, either professionally or academically. Be experienced with popular frameworks like Tensorflow, PyTorch, etc. - Have extensive Haskell experience. Be completely comfortable using (or learning) libraries like `lens`, `servant`, `singletons`, etc. Author of popular Haskell libraries. Worked on multiple large applications. - Have experience developing web apps using any of JavaScript, TypeScript, PureScript, Elm, GHCJS, and have created web apps using frameworks like Vue, Angular, React, Halogen, Reflex, or Miso. Ideally with a backend REST API implemented in Haskell. - Able to work full-time (40 hours a week) or **part-time** (20+ hours a week). - Willing to do freelance with us for a few weeks to make sure we are a good match for each other before becoming an permanent employee. - Able to work either on-site or **remote** - In the case of remote, you live in near Japan's timezone (UTC+9) and can fly to the office in Tokyo multiple times per year. (This requirement could be waived for strong candidates.) - Experience as a team-lead, chopping up and assigning tasks to less experienced Haskellers, reviewing PRs, etc. ## Flexible with job requirements We realize there are probably very few people that actually meet all these points. We are flexible, so please feel free to get in touch even if you don't think you meet our ideal requirements. It is possible for us to hire remotely, although we prefer people that are near Japan's timezone (UTC+9) and can fly to the office in Tokyo multiple times per year. We can also sponsor visas for people that want to move to Japan. As stated above, we are also open to applicants who want to do non-full-time work (20+ hours per week). Here are two examples of people we would love to talk to even though they don't meet all of the points above: ### Example 1: - Going to graduate school in Tokyo for machine learning. Very familiar with deep learning. - Beginning Haskeller. Have read through all of Haskell Programming From First Principles (and perhaps [Thinking with Types](https://leanpub.com/thinking-with-types)?) but has no experience working with large applications. - Able to come in to the office 20 to 25 hours a week. ### Example 2: - Living in Australia - Intimately familiar with Haskell, author of multiple popular libraries. - Very competent with web programming. - No experience with machine learning. - Multiple years of experience working remotely. - Able to work full-time. ## Some of the benefits of working at Cross Compass: - Work with passionate Haskellers. You may have seen us either here on [/r/haskell](https://www.reddit.com/r/haskell), or at conferences: - [Hideaki Kawai](https://github.com/kayhide) - [Viktor Kronvall](https://github.com/considerate) - [Ramin Honary](https://github.com/RaminHAL9001) - [Dennis Gosnell](https://functor.tokyo/) - We also work with [Tweag I/O](https://www.tweag.io). Their Haskellers are really top class. - Attend conferences like ICFP, Lambda Jam, etc. We each try to attend a couple conferences a year. - Training. We are planning to have the entire team take the [Guide to Haskell Performance and Optimization](https://www.well-typed.com/services_training_performance_and_… course from Well-Typed at some point. The lower end of the pay scale is 8 Million Yen (800万円) per year for full-time. I'm not sure what the higher end is. If this sounds interesting, please feel free to email us atrecruit-haskell(a)cross-compass.com, possibly with your resume and why you think we'd be good for each other. If you want to know more, we would love to take you out to lunch if you're located in Tokyo, or chat with you on Skype if not.

1 0

Taking over a package bindings-librrd
by Alexandr Fedorov 26 Nov '18

26 Nov '18

Hello, this package looks abandoned and does not compile on the latest librrd library. Let me clarify this: if MasatakeDaimon can hear this letter, please add me to bindings-librrd maintainers list, i'd be more than happy to help and a taking over is not necessary, but if somehow he still doesn't show up, hackage administrator please consider either adding me as a maintainer, or let me take over this package.

1 0

Help with DataKinds example
by Marc Busqué 24 Nov '18

24 Nov '18

I'm reading Sandy Maguire book Thinking with Types, and I'm stuck understanding an example about `DataKinds` language extension. In the book, it is said that it can be used to prevent at the type level that non admin users perform some action for which admin privileges are required. So, in the example, having `DataKinds` enabled, we define: ``` data UserType = User | Admin ``` Then, we change User type: ``` data User = User { userAdminToken :: Maybe (Proxy 'Admin) } ``` And then it is said that we can enforce that sensitive operations are performed by a user with the admin token: ``` doSensitiveThings :: Proxy 'Admin -> IO () ``` No other language extensions have been explained before in the book, and I simply don't understand how it is works... First, I guess that when writing `data User = ...` we are overriding `'User` promoted data constructor. Isn't it? Also, I don't understand how I could define a type `Proxy 'Admin`. If I'm not wrong, `Proxy` should have the kind `UserType -> *`, but I don't know how to do that. Besides that, I would like some guidance in the general idea of the example, because I'm quite puzzled :) Thanks in advance! Marc Busqué http://waiting-for-dev.github.io/about/

3 3

static analysis of a C-like language
by Olaf Klinke 22 Nov '18

22 Nov '18

Dear Cafe, I want to build a linter for a C-like language. My company uses a UI system that comes with a C-like language that is used to provide functionality to the UI elements. The language is interpreted at runtime. The user, however, has no access to the built-in parser and checking functions. Only a basic syntax check comes with their editor. Therefore many stupid mistakes only show at runtime and can not be tested for statically. The language is in many respects even simpler than C. No structs, no enumerations, only a handful of basic data types and arrays thereof, plus pointers and the usual control flow structures. On the other hand, there are some features that make static analysis near impossible, e.g. the possibility of dynamic registration of variables. Higher-order types are emulated by passing the name of other functions as strings. There is explicit referencing of other sources (#include statements) as well as implicit referencing within UI elements and within the project hierarchy. We want to catch basic programming mistakes - misspelled variables, missing return statements, usage of variables before assignment, wrong number of function arguments/types. A project's code is scattered across multiple files and layers - a function declaration can mask a declaration from the layer below. Therefore, a per-file-linter will not suffice. As a side-effect this may also yield a documentation generator (boy do I miss haddock while working with that), which is also missing in the system. I have never done something like this and will seek help from local CS departments (If you are a CS student in Paderborn or Bielefeld, Germany, get in touch!). My company would be willing to sponsor a Bachelor or Master's thesis project. Ultimately this will be comercialized as an add-on, so anyone who helps will also profit from the result financially. The user community is not large, but includes big names such as Siemens, London Heathrow, the Metros in NYC and Bilbao, and CERN. What kind of expertise shall I look for? Compiler theorists? What information shall I request from the language author? I feel that Haskell might be a good language to represent the AST in. But I am overwhelmed by the numerous AST libraries on hackage. How similar is my problem to what is covered by, say, haskell-src-exts, hlint, alex or syntactic? Can I re-use code from these projects? What solutions are out there for dependency resolution between source files? I suppose for informative error messages I need to decorate each semantic bit with information about - source file and location - what is in scope at that position, plus the source of the symbols in scope What data structures can be used to build and represent this information? Any pointers welcome. Olaf

3 3

Re: [Haskell-cafe] Feedback on plan for checking code requirements in a GHC plugin
by Johannes Waldmann 21 Nov '18

21 Nov '18

> Has anyone done anything like this before? Sort-of. Not with a GHC plugin, but haskell-src-exts to get the AST, and then match with a blueprint for the code (students have to replace "undefined" by some expression). See "How I Teach Functional Programming" (WFLP 2017) https://www.imn.htwk-leipzig.de/~waldmann/talk/ - J.W.

1 0

Re: [Haskell-cafe] Specialize a function on types of arguments?
by Anthony Clayden 20 Nov '18

20 Nov '18

On Mon, 19 Nov 2018 at 21:03, Olaf Klinke wrote: >>* The top-level story is that I am trying to create a monad that somehow* *>*>* records the "intermediate steps" of computation.* >> > If it is only for knowing where things went wrong, ... Thanks Olaf, no I think Ducis wants to stack the whole history of the computation. > If ... Then you need to stack a state transformer on top, Yes a monad transformer might be it. Thank you for the example. As per my previous message, I'm not convinced it needs monads at all. Here's a dumb approach as a straw man, showing that type-changing steps are nothing special (or perhaps I mean type-preserving steps are nothing special ;-). Ducis could explain why this won't do nil = () cons x l = (x, l) start :: a -> (a,()) start x = cons x nil -- i.e. singleton x infixl 0 $>> ($>>) :: (b, _a) -> (b -> c) -> (c, (b, _a)) xs@(x, z) $>> f = cons (f x) xs eg = start 1 $>> (+ 1) $>> (+ 3) $>> double $>> show ===> ("10",(10,(5,(2,(1,()))))) I chose ($>>) to be similar to ($>) from the Control.FPipe package "trivial F#-style pipes for function composition and application". You could use Datakind `'[]` instead of the 'poor man's heterogeneous list' I've used, but that seems over-engineering. AntC

1 0

Re: [Haskell-cafe] Specialize a function on types of arguments?
by Olaf Klinke 20 Nov '18

20 Nov '18

> > The top-level story is that I am trying to create a monad that somehow > records the "intermediate steps" of computation. > If it is only for knowing where things went wrong, isn't that what the Either monad is for? The semantics of (Either YourErrorType) is that it returns `Right result' when all steps went through, and `Left errmsg' from the first place where something went wrong. You'd have to define YourErrorType to incorporate the relevant error information. If you also want something like a call stack, i.e. a message like "computation failed in step 3 with message: foo" Then you need to stack a state transformer on top, e.g. StateT CallStack (Either YourErrorType) which decodes to CallStack -> Either YourErrorType (resultType,CallStack) An example using mtl transformers: import Control.Monad.State.Strict import Control.Monad.Except type CallStack = (Int,[String]) type YourErrorType = String type M a = StateT CallStack (Except YourError) a fancyFunc :: Show a => (a -> b) -> (a -> M b) fancyFunc f a = do (n,stack) <- get put (n+1,show a : stack) return b fancyMaybe :: Show a => (a -> Maybe b) -> (a -> M b) fancyMaybe f a = do (n,stack) <- get case (f a) of Nothing -> throwError $ "Failed at step "++(show n)++" on input "++(show a) Just b -> do put (n+1,show a : stack) return b runChainOfComputations = runStateT (1,[]) I once wrote a type 'ProvenienceT' which is a bit fancier than the above. It is a monadic EDSL and constructs a graph where nodes are (Markup of) intermediate steps of a computation and where edges are (user-supplied descriptions of) functions. It is inspired by the Javelin software of the 80s which pre-dates Excel spreadsheets. The result can be rendered as html. Can provide code if anyone is interested. Cheers, Olaf

1 0

Re: [Haskell-cafe] Specialize a function on types of arguments?
by ducis 19 Nov '18

19 Nov '18

Hi, Anthony, The top-level story is that I am trying to create a monad that somehow records the "intermediate steps" of computation. e.g. something like Prelude> return 1 ([],1) Prelude> return 1 >>= return.(+1) ([1],2) Prelude> return 1 >>= return.(+1)>>=return.(+3) ([2,1],5) (the list has the intermediate steps placed right-to-left so that new steps are appended to the left of the older steps) Of course all "intermediate steps of computation" actually form a graph, but we are frequently focused on, say, the transformation of a parse tree, where we want to take a series of snapshots of one "thing". Since a "lifted function" (e.g. return.(+1)) has in general the type a->m b, there are two ways to deal with input and output being not necessarily equal. The first approach I tried is to only record latest steps starting with the last change of type > newtype WithHistory b = WH ([b], b) and just discard the older steps when the input and output are of different types. > newtype WithHistory b = WH ([b], b) deriving (Show,Eq) > instance Monad WithHistory where > return b = WH ([], b) > (>>=) :: forall a b. WithHistory a -> (a -> WithHistory b) -> WithHistory b > WH (h,a) >>= fm = WH (h1++coerceHistory (a:h),b) > where > WH (h1, b) = fm a > class CoerceHistory a b where > coerceHistory :: [a] -> [b] > instance CoerceHistory a a where > coerceHistory = id > instance CoerceHistory a b where > coerceHistory _ = [] I have got the coerceHistory function to (appear to) work in GHCi *Main> coerceHistory [2::Int] :: [Int] [2] *Main> coerceHistory "c" :: [Int] [] But the Monad instanciation does not really work. GHC(7.6.3) hints for -XIncoherentInstances, which when enabled seems to force the (>>=) to always use the instance of coerceHistory returning [] The second approach is to use [Dynamic] for steps, i.e., > newtype WithHistory b = WH ([Dynamic], b) > instance Monad WithHistory where > return b = WH ([], b) > WH (h,a) >>= fm = WH (h1++forceDynList a++h, b) > where WH (h1, b) = fm a and presumably > class ForceDynList a where forceDynList :: a -> [Dynamic] > instance (Typeable a) => ForceDynList a where forceDynList x = [toDyn x] > instance ForceDynList a where forceDynList x = [] which is far from correct with error "Duplicate instance declarations" Thanks! Ducis -- ----------------------------- At 2018-11-18 20:00:01, haskell-cafe-request(a)haskell.org wrote: >Send Haskell-Cafe mailing list submissions to > haskell-cafe(a)haskell.org > >To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >or, via email, send a message with subject or body 'help' to > haskell-cafe-request(a)haskell.org > >You can reach the person managing the list at > haskell-cafe-owner(a)haskell.org > >When replying, please edit your Subject line so it is more specific >than "Re: Contents of Haskell-Cafe digest..." > > >Today's Topics: > > 1. Timing out a pure evaluation of an expression I did not write > myself (Ryan Reich) > 2. Re: Timing out a pure evaluation of an expression I did not > write myself (Daniel Díaz Casanueva) > 3. Re: Timing out a pure evaluation of an expression I did not > write myself (Daniel Díaz Casanueva) > 4. Re: Timing out a pure evaluation of an expression I did not > write myself (Ryan Reich) > 5. Specialize a function on types of arguments? (ducis) > 6. Re: Specialize a function on types of arguments? (Anthony Clayden) > 7. Re: Timing out a pure evaluation of an expression I did not > write myself (arjenvanweelden(a)gmail.com) > 8. external git dependency source in .cabal (Fabien R) > > >---------------------------------------------------------------------- > >Message: 1 >Date: Sat, 17 Nov 2018 15:21:53 -0800 >From: Ryan Reich <ryan.reich(a)gmail.com> >To: haskell-cafe <haskell-cafe(a)haskell.org> >Subject: [Haskell-cafe] Timing out a pure evaluation of an expression > I did not write myself >Message-ID: > <CAO8Ocku%2B%3D6GkyW-z8bShr7OSJppT_yPmrkcknF%3DUXYDn7%2BKBQg(a)mail.gmail.com> >Content-Type: text/plain; charset="utf-8" > >I want to time out a pure computation. My experience, and that described >in various previous questions here and elsewhere (the best of which is >https://mail.haskell.org/pipermail/haskell-cafe/2011-February/088820.html) >is that this doesn't always work: for instance, > >>>> timeout 1 $ evaluate $ let x = 0 : x in last x > >does not time out because, apparently, the fact that the expression >evaluates in constant space (i.e. never allocates) means that it never >yields to the timeout monitor thread that would kill it. > >The solution that is described in the other iterations is to embed >checkpoints in the expression that do allocate, giving the RTS a chance to >switch contexts. However, in my application, the expression is /arbitrary/ >and I do not have the freedom to inject alterations into it. (Don't argue >this point, please. The expression is arbitrary.) > >How can I time out a tight loop like the above? Clearly, it can be done, >because I can, say, alt-tab over to another terminal and kill the process, >which exploits the operating system's more aggressively pre-emptive >scheduling. Is there a solution using bound threads, say 'forkOS' instead >of 'forkIO' in the implementation of 'timeout'? Unix signals? Some >FFI-based workaround? Etc. Keep in mind that notwithstanding that >comment, I don't actually want to kill the whole process, but just the one >evaluation. > >Thanks in advance, >Ryan Reich >

2 1

external git dependency source in .cabal
by Fabien R 19 Nov '18

19 Nov '18

Hello, I'm trying to reference an external source of a package within a sandbox, using cabal 2.0.0.1: source-repository head type: git location: <git URL of pack1> executable myExe build-depends: base==4.10.1.0, pack1 -any But "cabal -v install --only-dependencies" fails: cabal: Encountered missing dependencies: pack1 -any Any hint ? -- Fabien

4 5

Re: [Haskell-cafe] Haskell-Cafe Digest, Vol 183, Issue 14
by ducis 19 Nov '18

19 Nov '18

Hi, Anthony, The top-level story is that I am trying to create a monad that somehow records the "intermediate steps" of computation. e.g. something like Prelude> return 1 ([],1) Prelude> return 1 >>= return.(+1) ([1],2) Prelude> return 1 >>= return.(+1)>>=return.(+3) ([2,1],5) (the list has the intermediate steps placed right-to-left so that new steps are appended to the left of the older steps) Of course all "intermediate steps of computation" actually form a graph, but we are frequently focused on, say, the transformation of a parse tree, where we want to take a series of snapshots of one "thing". Since a "lifted function" (e.g. return.(+1)) has in general the type a->m b, there are two ways to deal with input and output being not necessarily equal. The first approach I tried is to only record latest steps starting with the last change of type > newtype WithHistory b = WH ([b], b) and just discard the older steps when the input and output are of different types. > newtype WithHistory b = WH ([b], b) deriving (Show,Eq) > instance Monad WithHistory where > return b = WH ([], b) > (>>=) :: forall a b. WithHistory a -> (a -> WithHistory b) -> WithHistory b > WH (h,a) >>= fm = WH (h1++coerceHistory (a:h),b) > where > WH (h1, b) = fm a > class CoerceHistory a b where > coerceHistory :: [a] -> [b] > instance CoerceHistory a a where > coerceHistory = id > instance CoerceHistory a b where > coerceHistory _ = [] I have got the coerceHistory function to (appear to) work in GHCi *Main> coerceHistory [2::Int] :: [Int] [2] *Main> coerceHistory "c" :: [Int] [] But the Monad instanciation does not really work. GHC(7.6.3) hints for -XIncoherentInstances, which when enabled seems to force the (>>=) to always use the instance of coerceHistory returning [] The second approach is to use [Dynamic] for steps, i.e., > newtype WithHistory b = WH ([Dynamic], b) > instance Monad WithHistory where > return b = WH ([], b) > WH (h,a) >>= fm = WH (h1++forceDynList a++h, b) > where WH (h1, b) = fm a and presumably > class ForceDynList a where forceDynList :: a -> [Dynamic] > instance (Typeable a) => ForceDynList a where forceDynList x = [toDyn x] > instance ForceDynList a where forceDynList x = [] which is far from correct with error "Duplicate instance declarations" Thanks! Ducis -- ----------------------------- At 2018-11-18 20:00:01, haskell-cafe-request(a)haskell.org wrote: >Send Haskell-Cafe mailing list submissions to > haskell-cafe(a)haskell.org > >To subscribe or unsubscribe via the World Wide Web, visit > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >or, via email, send a message with subject or body 'help' to > haskell-cafe-request(a)haskell.org > >You can reach the person managing the list at > haskell-cafe-owner(a)haskell.org > >When replying, please edit your Subject line so it is more specific >than "Re: Contents of Haskell-Cafe digest..." > > >Today's Topics: > > 1. Timing out a pure evaluation of an expression I did not write > myself (Ryan Reich) > 2. Re: Timing out a pure evaluation of an expression I did not > write myself (Daniel Díaz Casanueva) > 3. Re: Timing out a pure evaluation of an expression I did not > write myself (Daniel Díaz Casanueva) > 4. Re: Timing out a pure evaluation of an expression I did not > write myself (Ryan Reich) > 5. Specialize a function on types of arguments? (ducis) > 6. Re: Specialize a function on types of arguments? (Anthony Clayden) > 7. Re: Timing out a pure evaluation of an expression I did not > write myself (arjenvanweelden(a)gmail.com) > 8. external git dependency source in .cabal (Fabien R) > > >---------------------------------------------------------------------- > >Message: 1 >Date: Sat, 17 Nov 2018 15:21:53 -0800 >From: Ryan Reich <ryan.reich(a)gmail.com> >To: haskell-cafe <haskell-cafe(a)haskell.org> >Subject: [Haskell-cafe] Timing out a pure evaluation of an expression > I did not write myself >Message-ID: > <CAO8Ocku%2B%3D6GkyW-z8bShr7OSJppT_yPmrkcknF%3DUXYDn7%2BKBQg(a)mail.gmail.com> >Content-Type: text/plain; charset="utf-8" > >I want to time out a pure computation. My experience, and that described >in various previous questions here and elsewhere (the best of which is >https://mail.haskell.org/pipermail/haskell-cafe/2011-February/088820.html) >is that this doesn't always work: for instance, > >>>> timeout 1 $ evaluate $ let x = 0 : x in last x > >does not time out because, apparently, the fact that the expression >evaluates in constant space (i.e. never allocates) means that it never >yields to the timeout monitor thread that would kill it. > >The solution that is described in the other iterations is to embed >checkpoints in the expression that do allocate, giving the RTS a chance to >switch contexts. However, in my application, the expression is /arbitrary/ >and I do not have the freedom to inject alterations into it. (Don't argue >this point, please. The expression is arbitrary.) > >How can I time out a tight loop like the above? Clearly, it can be done, >because I can, say, alt-tab over to another terminal and kill the process, >which exploits the operating system's more aggressively pre-emptive >scheduling. Is there a solution using bound threads, say 'forkOS' instead >of 'forkIO' in the implementation of 'timeout'? Unix signals? Some >FFI-based workaround? Etc. Keep in mind that notwithstanding that >comment, I don't actually want to kill the whole process, but just the one >evaluation. > >Thanks in advance, >Ryan Reich >

2 2