Re: [Haskell-cafe] ANNOUNCE: hoppy, qtah

On Tue, 9 Feb 2016 09:59:37 +0100 Nicola Gigante wrote:

...

Il giorno 08 feb 2016, alle ore 19:11, Bryan Gardiner ha scritto:

Are you sick and tired of the ease with which Haskell code flows onto the page? Even the thrill of binding to a C library losing its lustre? Look no further! I present to you a tool restoring the good old days of pointer arithmetic, manual memory management, and hours lost to the debugger:

Hoppy is a new C++ FFI generator for Haskell. It takes Haskell code that describes a C++ API, and generates C++ and Haskell code to allow the two languages to interact. It supports a good subset of C++, including functions, classes, variables, enums and bitflags, operator overloading, constness, and simple templates. Adding a function takes only a few lines of code, and you normally don't need to write C++ yourself. For example, a definition for std::string is:

c_string :: Class c_string = addReqIncludes [includeStd "string"] $ classAddFeatures [Assignable, Comparable, Copyable, Equatable] $ makeClass (ident1 "std" "string") (Just $ toExtName "StdString") [] [ mkCtor "new" [] , mkCtor "newFromCString" [TPtr $ TConst TChar] ] [ mkConstMethod' "at" "at" [TInt] $ TRef TChar , mkConstMethod' "at" "get" [TInt] TChar , mkConstMethod "c_str" [] $ TPtr $ TConst TChar , mkConstMethod "size" [] TSize , mkConstMethod OpAdd [TObj c_string] $ TObj c_string ]

Now, writing a FFI generator isn't much fun unless you have a project to use it with. So I am pleased to also announce Qtah, a fresh set of Qt 4/5 bindings. These include portions of QtCore, QtGui, and QtWidgets, and are on the whole wildly incomplete, but are usable for basic tasks so far, and I am working on extending coverage.

(On qtHaskell/hsQt: I started Qtah before qtHaskell began being updated in 2015 and I missed when that happened. My hope is that Qtah requires less code and effort to maintain; at least, qtHaskell contains a lot of generated code and I haven't seen where it came from, so please correct me if the generator is in fact available somewhere. Hoppy also doesn't (currently) do many of the fancy things that qtHaskell does, like overloading and garbage collection.)

Both Hoppy and Qtah are young, and I am very interested in discussing how to make them most useful for the community. Because of questions such as this[1], their APIs (including those of generated bindings) should be considered experimental at this time.

I will be uploading Hoppy to Hackage shortly. Becuase Qtah includes a shared library, I haven't figured out how to get that on Hackage yet, so you'll have to clone the repo yourself.

http://khumba.net/projects/hoppy

http://khumba.net/projects/qtah

Happy hacking!

Hi Nicola,

That’s wonderful!

A couple of questions: - Do you think it would fit well to provide a monadic interface to construct a clean and readable DSL on top of your functions?

Yes! Really good idea. That would also help with referring to the right "version" of a class, since right now there are lots of 'Class -> Class' functions, and you have to be a little careful about capturing references to old state (this needs better documentation).

- What is the definition of “simple” template?

Template parameters must be non-template types. Literals, nested templates (Foo), and things required for template metaprogramming can't be used yet because of how Identifier and Type are structured. These are things I want to change (and shouldn't be hard) but just haven't needed yet. C++11 type synonyms provide a workaround. (I'm actually cheating a little. Hoppy doesn't care about templates, only instantiations, which are just regular classes/functions. Hoppy provides the ability to specify template parameters as part of an identifier, and instantiation is left up to bindings authors. I while back I did have data types for templates, but it had versioning issues as above, and didn't let a template refer to its future instantiation.) Cheers, Bryan