6 ms·

The Mercury logic programming system

52 points by pplonski86 8y ago

vore 8y ago
No mention of Mercury is complete without mentioning PrinceXML, the only software I have ever seen using Mercury in production: https://www.princexml.com/doc-refs/#acknowledgments https://www.princexml.com/doc-refs/#acknowledgments
- alhimik45 8y ago
  Hmm, converting HTML to Pdf doesn't look like a task for logic programming language. Why did they choose Mercury?
  - ainar-g 8y ago
    That's a peculiar opinion. Usually, whenever discussion comes to parsing and codecs, people like to mention how the problem P could be solved with a purely functional language L so much more elegantly. And yes, logic and purely functional languages are not the same, but they seem to be very close relatives.
    - tluyben2 8y ago
      I mentioned to my Haskell teacher in uni that I did 2 years of intensive Prolog for an AI course at another uni and so that I grasp the basics or ‘everything recursion’ (mind you, this is 25 years or so ago). He got angry and said the two have nothing in common and if I believe that I definitely should pay more attention. It was weird as I did not say they are alike; just that they share some concepts which are usually hard to understand for imperative programmers, but, after 2 years of breathing Prolog really are second nature.
      - ainar-g 8y ago
        Honestly, that speaks more about the teacher's personal issues than it does about the similarities between logic and purely functional programming. I'm sorry that you had to experience that.
      - garmaine 8y ago
        Sibling comment is spot on. Your "teacher" was either not well informed or dealing with some issues himself. To cathartically let go of that experience, I suggest reading up on Curry, the logical language extension to Haskell: https://en.wikipedia.org/wiki/Curry_(programming_language) https://en.wikipedia.org/wiki/Curry_(programming_language)
      - bjz_ 8y ago
        Waaaaaat. There's so much in Haskell's type system that is also in logic programming. Like Hindley-Milner type inference and type class instance resolution.
  - timClicks 8y ago
    Am not a Prince developer, but I can imagine that a logic programming language would greatly simplify some of constraint solving tasks.
    - bjz_ 8y ago
      Funnily enough we don't actually use the built-in non-determinism all that much. Often the layout tasks that HTML and CSS demand require us to build our own, bespoke algorithms, for performance and control reasons. We still get a bunch of leverage out of the type system and data modelling power of the language though.
      - timClicks 8y ago
        That's really fascinating (& thanks for taking the time to comment).
  - bjz_ 8y ago
    I work at YesLogic and answered a similar question on Lobste.rs recently: https://lobste.rs/s/7op1vm/my_first_3_weeks_professional_rust#c_82kibi https://lobste.rs/s/7op1vm/my_first_3_weeks_professional_rus... The gist of it (as far as I understand it) is that at the time Prince was started (around 2003?), there wasn't a declarative/functional programming language out there to use that was fast enough, or had as much interest in low level control as Mercury had. The founders were pretty convinced that this was the style of programming they wanted to do, and the creators of Mercury were locals to Melbourne, so that kind of tipped things in Mercury's favor. In general we tend to use the functional/typed parts of the language more than the logic parts of the language (although that can be handy at times). Pretty much any form of programming can benefit from being expressed in that way. It might be that the team is so highly competent, but the Prince source is one of the best I've seen, even after all these years, and it's still reasonably easy to make changes without fear. That's mainly what we get out of Mercury.
alexchamberlain 8y ago
I'm sure this is awesome, but there's no code examples until I download a read a PDF tutorial. I think a couple of examples in the README or on the homepage could go a long way. What differiates this from Prolog or Datalog?
- kiriakasis 8y ago
  More expressive than datalog, faster than Prolog.
  - lpu4o74p 8y ago
    However, less expressive than Prolog
    - srean 8y ago
      Could you explain or point to any discussion on why would that be.
      - bjz_ 8y ago
        Mercury brings a bit more sanity to Prolog with its mode system. This is one of the key reasons why it runs fast and can be used to build big systems like Prince. That said, it _is_ a restriction on expressiveness of programs, and sometimes that makes it hard to do certain things. That's true of any type system. There's still an interesting question about whether a different iteration on the mode system could capture more of the semantics of Prolog while still being useful, but so far nobody has done that research yet. It's more trendy to do FP research these days, so I'm expecting it could be a _long_ time before we get an answer, sadly.
- bjz_ 8y ago
  > I'm sure this is awesome, but there's no code examples until I download a read a PDF tutorial. Yeah, I definitely think this is something that could be improved - Mercury tends to come from a more 'old-school' form of OSS where the importance of marketing and design was less well understood. I hope they get around to fixing this! The biggest thing that Mercury brings to the table is types, a mode system, and performance. This makes it viable for large scale software development.
garyclarke27 8y ago
Anyone know how this compares to Picat? I spent some time looking at Picat and plan to use it in the future in an (mainly SQL) ERP system for solving constraint decision problems. Picat is v nice, I could never get my head around Prolog, Picat is much easier for me to grok and appears to be a lot more powerful.
pmontra 8y ago
The are examples in the wiki, but there are no references to that in the repo README. The authors should fix that. This is the hello world :- module hello. :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. main(!IO) :- write_string("Hello, world!\n", !IO). My first reaction is why that :- at the beginning of the first lines? I'm sure there are pretty good reasons for it, probably because of the history of this lineage of programming languages. That's fine if the authors are interested only in developers from that background. If they want to expand to the general developers community they should adopt a more mainstream syntax which will ease onboarding. Elixir gave a nice lesson about that, by giving Erlang a Ruby like syntax and onboarding many developers from non functional languages. Then Elixir is still Erlang and functional. Probably the interpreter/compiler can do some more work and be able to understand what module, interface, import_module, pred and implementation are without the :- prefix. To my eyes that :- is only noise, I don't need it to read and understand the program. The language should help me, not the other way around. Other points along the same line: * The ! before IO reminds of the not operator in other languages and I wonder what it means. I should read the documentation but it feels strange. * The :- again after the function definition. Other languages have either simpler characters to type (Ruby and Elixir have do, Python has :, C and Java have { ). * The . at the end of statements. From other examples it seems that Mercury uses it exactly as Erlang does (one(), two(), three().) Elixir managed not to use neither commas nor the full stop. It uses do end instead ({} is more popular). Python use a different approach which I don't like but it's popular too.
- triska 8y ago
  Mercury's roots are indeed the explanation and justification for many of these points: Mercury syntax is deliberately designed to be very close to Prolog syntax. In fact, it is so close to Prolog that if you remove the declarations, then many Mercury programs are also valid Prolog code. Regarding ":-", there is a difference between writing: :- implementation. and implementation. The latter is a fact and can be read as "implementation holds". The former is a directive that tells the compiler something. As in Prolog, :- is an ASCII transliteration of ←, i.e., an arrow from right to left. A clause of the form: Head :- Body. is read as: "If Body is true, then Head is true.". Such clauses are sufficient to describe every known computation. In Mercury, !Var is a state variable. It is a shorthand for naming intermediate values in a sequence. Without using state variables, you can write the code equivalently as: main(IO0, IO) :- write_string("Hello, world!\n", IO0, IO). State variables are more explicit than using DCG notation, and at the same time still easier to write than pairs of variables that are threaded through. The "." at the end of clauses is likewise inspired by Prolog syntax. Please note that Prolog programs are, syntactically, also Prolog terms, and "." is used at the end of each clause.
tluyben2 8y ago
This language has been around for ages and does not get enough attention imho; it is a very fast Prolog like and it has been robust for a while now. But almost no one uses it unfortunately...
- colanderman 8y ago
  I used Mercury intensively for about a year a while ago. I think what ultimately turned me off was the incompleteness of the implementation (several of the most interesting features were only 80% implemented, and the unimplemented corner cases were undocumented and caused the compiler to crash, so you just had to guess what it was you were doing that was too advanced), and the incomprehensibility of the error messages (an order of magnitude even more incomprehensible than C++ template errors). Notably, the lack of support from the instantiatedness system for partially instantiated structures put Mercury at a big disadvantage to Prolog's expressiveness in my opinion. So now, instead of using Mercury and wishing it better supported partial instantiation and had comprehensible error messages, I use Prolog and wish it had even a basic static analyzer and support for the !Var and @Var syntaxes.

52 points by pplonski86 8y ago

vore 8y ago

No mention of Mercury is complete without mentioning PrinceXML, the only software I have ever seen using Mercury in production: https://www.princexml.com/doc-refs/#acknowledgments https://www.princexml.com/doc-refs/#acknowledgments

alhimik45 8y ago
Hmm, converting HTML to Pdf doesn't look like a task for logic programming language. Why did they choose Mercury?
- ainar-g 8y ago
  That's a peculiar opinion. Usually, whenever discussion comes to parsing and codecs, people like to mention how the problem P could be solved with a purely functional language L so much more elegantly. And yes, logic and purely functional languages are not the same, but they seem to be very close relatives.
  - tluyben2 8y ago
    I mentioned to my Haskell teacher in uni that I did 2 years of intensive Prolog for an AI course at another uni and so that I grasp the basics or ‘everything recursion’ (mind you, this is 25 years or so ago). He got angry and said the two have nothing in common and if I believe that I definitely should pay more attention. It was weird as I did not say they are alike; just that they share some concepts which are usually hard to understand for imperative programmers, but, after 2 years of breathing Prolog really are second nature.
    - ainar-g 8y ago
      Honestly, that speaks more about the teacher's personal issues than it does about the similarities between logic and purely functional programming. I'm sorry that you had to experience that.
    - garmaine 8y ago
      Sibling comment is spot on. Your "teacher" was either not well informed or dealing with some issues himself. To cathartically let go of that experience, I suggest reading up on Curry, the logical language extension to Haskell: https://en.wikipedia.org/wiki/Curry_(programming_language) https://en.wikipedia.org/wiki/Curry_(programming_language)
    - bjz_ 8y ago
      Waaaaaat. There's so much in Haskell's type system that is also in logic programming. Like Hindley-Milner type inference and type class instance resolution.
- timClicks 8y ago
  Am not a Prince developer, but I can imagine that a logic programming language would greatly simplify some of constraint solving tasks.
  - bjz_ 8y ago
    Funnily enough we don't actually use the built-in non-determinism all that much. Often the layout tasks that HTML and CSS demand require us to build our own, bespoke algorithms, for performance and control reasons. We still get a bunch of leverage out of the type system and data modelling power of the language though.
    - timClicks 8y ago
      That's really fascinating (& thanks for taking the time to comment).
- bjz_ 8y ago
  I work at YesLogic and answered a similar question on Lobste.rs recently: https://lobste.rs/s/7op1vm/my_first_3_weeks_professional_rust#c_82kibi https://lobste.rs/s/7op1vm/my_first_3_weeks_professional_rus... The gist of it (as far as I understand it) is that at the time Prince was started (around 2003?), there wasn't a declarative/functional programming language out there to use that was fast enough, or had as much interest in low level control as Mercury had. The founders were pretty convinced that this was the style of programming they wanted to do, and the creators of Mercury were locals to Melbourne, so that kind of tipped things in Mercury's favor. In general we tend to use the functional/typed parts of the language more than the logic parts of the language (although that can be handy at times). Pretty much any form of programming can benefit from being expressed in that way. It might be that the team is so highly competent, but the Prince source is one of the best I've seen, even after all these years, and it's still reasonably easy to make changes without fear. That's mainly what we get out of Mercury.

alexchamberlain 8y ago

I'm sure this is awesome, but there's no code examples until I download a read a PDF tutorial. I think a couple of examples in the README or on the homepage could go a long way. What differiates this from Prolog or Datalog?

kiriakasis 8y ago
More expressive than datalog, faster than Prolog.
- lpu4o74p 8y ago
  However, less expressive than Prolog
  - srean 8y ago
    Could you explain or point to any discussion on why would that be.
    - bjz_ 8y ago
      Mercury brings a bit more sanity to Prolog with its mode system. This is one of the key reasons why it runs fast and can be used to build big systems like Prince. That said, it _is_ a restriction on expressiveness of programs, and sometimes that makes it hard to do certain things. That's true of any type system. There's still an interesting question about whether a different iteration on the mode system could capture more of the semantics of Prolog while still being useful, but so far nobody has done that research yet. It's more trendy to do FP research these days, so I'm expecting it could be a _long_ time before we get an answer, sadly.
bjz_ 8y ago
> I'm sure this is awesome, but there's no code examples until I download a read a PDF tutorial. Yeah, I definitely think this is something that could be improved - Mercury tends to come from a more 'old-school' form of OSS where the importance of marketing and design was less well understood. I hope they get around to fixing this! The biggest thing that Mercury brings to the table is types, a mode system, and performance. This makes it viable for large scale software development.

garyclarke27 8y ago

Anyone know how this compares to Picat? I spent some time looking at Picat and plan to use it in the future in an (mainly SQL) ERP system for solving constraint decision problems. Picat is v nice, I could never get my head around Prolog, Picat is much easier for me to grok and appears to be a lot more powerful.

pmontra 8y ago

The are examples in the wiki, but there are no references to that in the repo README. The authors should fix that. This is the hello world :- module hello. :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. main(!IO) :- write_string("Hello, world!\n", !IO). My first reaction is why that :- at the beginning of the first lines? I'm sure there are pretty good reasons for it, probably because of the history of this lineage of programming languages. That's fine if the authors are interested only in developers from that background. If they want to expand to the general developers community they should adopt a more mainstream syntax which will ease onboarding. Elixir gave a nice lesson about that, by giving Erlang a Ruby like syntax and onboarding many developers from non functional languages. Then Elixir is still Erlang and functional. Probably the interpreter/compiler can do some more work and be able to understand what module, interface, import_module, pred and implementation are without the :- prefix. To my eyes that :- is only noise, I don't need it to read and understand the program. The language should help me, not the other way around. Other points along the same line: * The ! before IO reminds of the not operator in other languages and I wonder what it means. I should read the documentation but it feels strange. * The :- again after the function definition. Other languages have either simpler characters to type (Ruby and Elixir have do, Python has :, C and Java have { ). * The . at the end of statements. From other examples it seems that Mercury uses it exactly as Erlang does (one(), two(), three().) Elixir managed not to use neither commas nor the full stop. It uses do end instead ({} is more popular). Python use a different approach which I don't like but it's popular too.

triska 8y ago
Mercury's roots are indeed the explanation and justification for many of these points: Mercury syntax is deliberately designed to be very close to Prolog syntax. In fact, it is so close to Prolog that if you remove the declarations, then many Mercury programs are also valid Prolog code. Regarding ":-", there is a difference between writing: :- implementation. and implementation. The latter is a fact and can be read as "implementation holds". The former is a directive that tells the compiler something. As in Prolog, :- is an ASCII transliteration of ←, i.e., an arrow from right to left. A clause of the form: Head :- Body. is read as: "If Body is true, then Head is true.". Such clauses are sufficient to describe every known computation. In Mercury, !Var is a state variable. It is a shorthand for naming intermediate values in a sequence. Without using state variables, you can write the code equivalently as: main(IO0, IO) :- write_string("Hello, world!\n", IO0, IO). State variables are more explicit than using DCG notation, and at the same time still easier to write than pairs of variables that are threaded through. The "." at the end of clauses is likewise inspired by Prolog syntax. Please note that Prolog programs are, syntactically, also Prolog terms, and "." is used at the end of each clause.

tluyben2 8y ago

This language has been around for ages and does not get enough attention imho; it is a very fast Prolog like and it has been robust for a while now. But almost no one uses it unfortunately...

colanderman 8y ago
I used Mercury intensively for about a year a while ago. I think what ultimately turned me off was the incompleteness of the implementation (several of the most interesting features were only 80% implemented, and the unimplemented corner cases were undocumented and caused the compiler to crash, so you just had to guess what it was you were doing that was too advanced), and the incomprehensibility of the error messages (an order of magnitude even more incomprehensible than C++ template errors). Notably, the lack of support from the instantiatedness system for partially instantiated structures put Mercury at a big disadvantage to Prolog's expressiveness in my opinion. So now, instead of using Mercury and wishing it better supported partial instantiation and had comprehensible error messages, I use Prolog and wish it had even a basic static analyzer and support for the !Var and @Var syntaxes.