From andrei.h.popescu at gmail.com Mon Feb 3 14:37:28 2025 From: andrei.h.popescu at gmail.com (Andrei Popescu) Date: Mon, 3 Feb 2025 14:37:28 +0000 Subject: [Haskell-cafe] Midlands Graduate School 2025 hosted by the University of Sheffield Message-ID: Dear Colleagues, This year's Midlands Graduate School in the Foundations of Computing Science will take place at the University of Sheffield. We have some great lecturers and topics. (Below you can also find information about fees. The registration site will open soon.) Best wishes, Andrei Midlands Graduate School 2025 7-11 April 2025, Sheffield, UK https://tinyurl.com/MGS-2025 BACKGROUND The Midlands Graduate School (MGS) in the Foundations of Computing Science provides an intensive course of lectures on the mathematical foundations of computing. The MGS has been running since 1999, and is aimed at PhD students in their first or second year of study, but the school is open to everyone, and has increasingly seen participation from industry. We welcome participants from all over the world! COURSES Eight courses will be given. Participants usually take all the introductory courses and choose additional options from the advanced courses depending on their interests. Invited course - Four Lectures on Proof-Theoretic Semantics, David Pym Introductory courses - Category Theory, Thorsten Altenkirch - The Curry-Howard Correspondence, Anupam Das - Quantum Computing, Venanzio Capretta Advanced courses - Coalgebra, Paul Blain Levy - Linear Logic, Abhishek De and Charles Grellois - Modular Proofs in Isabelle/HOL, Chelsea Edmonds - Refinement Types in Haskell, Brandon Hewer FEES AND REGISTRATION The fees for MGS 25, which also cover catering (including coffee, pastries and lunch) during the day and optionally the conference dinner, are as follows. - Academic participant: £300, plus an optional £30 dinner ticket for Wednesday evening. - Industry participant: £500, plus an optional £30 dinner ticket for Wednesday evening. Registration will be open shortly. SPONSORSHIP We offer a range of sponsorship opportunities for industry (bronze, silver, gold and platinum), each with specific benefits. Please see the website for further details. From adbrucker at 0x5f.org Tue Feb 4 11:02:07 2025 From: adbrucker at 0x5f.org (Achim D. Brucker) Date: Tue, 4 Feb 2025 11:02:07 +0000 Subject: [Haskell-cafe] PhD Position: Verification of Golang using Interactive Theorem Proving (Application Deadline 2025-02-10) Message-ID: We have an exciting funded opportunity for a PhD on developing "Verification Environment for Distributed Systems Implemented in Go". The main objectives are to define a formal semantics of Go and its CSP-inspired concurrency model in an interactive theorem prover (e.g., Isabelle/HOL) as well as developing a calculus for program verification. This is a unique opportunity to work in the intersection of theory and application and while doing so, contributing to improving the state of the art in software correctness and security. A detailed description of the PhD proposal is available at: * https://www.exeter.ac.uk/v8media/recruitmentsites/documents/A_Verification_Environment_for_Distributed_Systems_Implemented_in_Go_EPSRC_DLA_Project_September_2025_Entry.pdf Information about the funding and application process is available at: * https://www.exeter.ac.uk/study/funding/award/?id=5477 Application deadline is the midnight GMT on 10th of February 2025. Please reach out to me, if you have any questions. Best, Achim -- Prof. Achim Brucker | Chair in Cybersecurity & Head of Group | University of Exeter https://www.brucker.ch | https://logicalhacking.com/blog @adbrucker | @logicalhacking From ivanperezdominguez at gmail.com Wed Feb 5 02:33:40 2025 From: ivanperezdominguez at gmail.com (Ivan Perez) Date: Tue, 4 Feb 2025 18:33:40 -0800 Subject: [Haskell-cafe] [ANN] NASA's Ogma 1.6.0 Message-ID: Hi everyone! I'm thrilled to announce the release of Ogma 1.6.0! NASA's Ogma is a mission assurance tool that facilitates integrating runtime monitors or runtime verification applications into other systems. Use cases supported by Ogma include producing Robot Operating System (ROS 2) packages [3], NASA Core Flight System (cFS) applications [4], and components for FPrime [1] (the software framework used for the Mars Helicopter). Ogma is also one of the solutions recommended for monitoring in Space ROS applications [2]. Ogma is fully written in Haskell, and leverages existing Haskell work, like the Copilot language [5] (also funded by NASA) and BNFC [6]. For more details, including videos of monitors being generated and flown in simulators, see: https://github.com/nasa/ogma * What's changed This major release includes the following improments: - Update Ogma to be able to extract data from XML files, including standard formats used in MBSE tools. - Provide a new diagram command capable of generating state machine implementations from diagrams. - Make the ROS and F' backend able to use any JSON- or XML files as input, makes the ROS, F', standalone backends capable of using literal Copilot expressions in requirements and state transitions. - Extend Ogma to be able to use external tools to translate requirements, including LLMs. - Make the F' backend able to use templates. - Allow users to provide custom definitions for XML and JSON formats unknown to the tool. - Fixes several other smaller maintenance issues. - Upgrades the README to include instructions for external contributors. This constitutes the single largest release of Ogma in number of new features added, since its first release. For details about the release, see: https://github.com/nasa/ogma/releases/tag/v1.6.0 * Releases Ogma is released as a collection of packages in Hackage. The entry point is https://hackage.haskell.org/package/ogma-cli. * Code The github repo is located at: https://github.com/nasa/ogma. * What's coming The next release is planned for Mar 21st, 2025. We are currently working on a GUI for Ogma that facilitates collecting all mission data relative to the design, diagrams, requirements and deployments, and help users refine designs and requirements, verify them for correctness, generate monitors and full applications, follow live missions, and produce reports. We also want to announce that both Ogma and Copilot can now accept contributions from external users, and we are also keen to see students use them for their school projects, their final projects and theses, and other research. If you are interested in collaborating, please reach out to ivan.perezdominguez at nasa.gov. We hope that you are as excited as we are and that our work demonstrates that, with the right support, Haskell can reach farther than we ever thought possible. Happy Haskelling! Ivan [1] https://github.com/nasa/fprime [2] https://space.ros.org/ [3] https://www.ros.org/ [4] https://github.com/nasa/cFS [5] https://github.com/Copilot-Language/copilot [6] https://github.com/BNFC/bnfc -------------- next part -------------- An HTML attachment was scrubbed... URL: From pranshu at bauherren.ovh Sat Feb 8 00:03:35 2025 From: pranshu at bauherren.ovh (Pranshu Sharma) Date: Sat, 08 Feb 2025 10:03:35 +1000 Subject: [Haskell-cafe] Course-of-value recursion by defining a sequence as a self-referential infinite list In-Reply-To: <4BA66911-6B17-4502-8179-B9D87E8A997F@gmail.com> (Vanessa McHale's message of "Wed, 22 Jan 2025 07:01:59 -0500") References: <4BA66911-6B17-4502-8179-B9D87E8A997F@gmail.com> Message-ID: <874j15uwtk.fsf@bauherren.ovh> Vanessa McHale writes: > I came up with a one-liner for computing coefficients of the generating function for integer > partitions: > > part :: Int → [Integer ] > part n = take n $ product [cycle (1 : replicate n 0) | n ← [0 . . (n − 2)]] > > Karczmarczuk’s solution via the Haskell prelude: > > part = 1 : b 1 > where b n = (1 : b (n + 1)) + (replicate n 0 ++ b n) > This is broken code, no?, just 2 reasons I can spot why: - function 'b n' calls 'b n' unconditionally (infite loop) - What is the reutrn type of 'b'? It seems like it returns list, but the return value is in the form 'a + b' , where (+) is instance of num so I don't think prelude contains any ad-hoc definition of (+) that returns list From theghostjw at gmail.com Sat Feb 8 21:40:23 2025 From: theghostjw at gmail.com (John Walker) Date: Sun, 9 Feb 2025 08:40:23 +1100 Subject: [Haskell-cafe] A Conversation With Sandy Maguire - Melbourne Haskell Users' Group - 28-03-2024 Message-ID: Hi All, Our interview with Sandy Maguire at Melbourne Haskell Users' Group, (now Melbourne Compose Group) is now on [YouTube](https://youtu.be/dnHIsr6gGnE). Sandy is well known in the Haskell and broader FP community, particularly as the author of: - [Thinking With Types](https://leanpub.com/thinking-with-types) - [Algebra Driven Design](https://leanpub.com/algebra-driven-design) - [Certainty By Construction](https://leanpub.com/certainty-by-construction) John -------------- next part -------------- An HTML attachment was scrubbed... URL: From douglas.mcilroy at dartmouth.edu Sat Feb 8 23:09:48 2025 From: douglas.mcilroy at dartmouth.edu (Douglas McIlroy) Date: Sat, 8 Feb 2025 18:09:48 -0500 Subject: [Haskell-cafe] Course-of-value recursion by defining a sequence as a self-referential infinite list Message-ID: >> Karczmarczuk’s solution via the Haskell prelude: >> >> part = 1 : b 1 >> where b n = (1 : b (n + 1)) + (replicate n 0 ++ b n) >> > This is broken code, no?, just 2 reasons I can spot why: > - function 'b n' calls 'b n' unconditionally (infite loop) > - What is the reutrn type of 'b'? It seems like it returns list, but the > return value is in the form 'a + b' , where (+) is instance of num so > I don't think prelude contains any ad-hoc definition of (+) that > returns list Not broken, just insufficiently documented. "part "is supposed to produce an infinite stream whose nth element is the number of distinct representations of n as a sum of positive integers. The "infinite loop" is deliberate, quite like ones = 1 : ones which generates an infinite sequence of 1s. It is not stated, but the (+) is understood to have been overloaded to handle lists of Nums in the natural way Doug -------------- next part -------------- An HTML attachment was scrubbed... URL: From ky3 at atamo.com Mon Feb 10 01:00:00 2025 From: ky3 at atamo.com (Kim-Ee Yeoh) Date: Mon, 10 Feb 2025 08:00:00 +0700 Subject: [Haskell-cafe] Course-of-value recursion by defining a sequence as a self-referential infinite list In-Reply-To: <874j15uwtk.fsf@bauherren.ovh> References: <4BA66911-6B17-4502-8179-B9D87E8A997F@gmail.com> <874j15uwtk.fsf@bauherren.ovh> Message-ID: On Sat, Feb 8, 2025 at 7:04 AM Pranshu Sharma via Haskell-Cafe < haskell-cafe at haskell.org> wrote: > Vanessa McHale writes: > > > > > > > Karczmarczuk’s solution via the Haskell prelude: > > > > part = 1 : b 1 > > where b n = (1 : b (n + 1)) + (replicate n 0 ++ b n) > > > > This is broken code, no?, just 2 reasons I can spot why: > - function 'b n' calls 'b n' unconditionally (infite loop) This definition is meaningful: ones = 1 : ones Now consider onesfun () = 1 : onesfun () The function onesfun calls itself unconditionally. This is broken code, no? > - What is the reutrn type of 'b'? It seems like it returns list, but the > return value is in the form 'a + b' , where (+) is instance of num so > I don't think prelude contains any ad-hoc definition of (+) that > returns list > _______________________________________________ > Haskell-Cafe mailing list > To (un)subscribe, modify options or view archives go to: > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > Only members subscribed via the mailman list are allowed to post. -------------- next part -------------- An HTML attachment was scrubbed... URL: From ky3 at atamo.com Mon Feb 10 01:00:00 2025 From: ky3 at atamo.com (Kim-Ee Yeoh) Date: Mon, 10 Feb 2025 08:00:00 +0700 Subject: [Haskell-cafe] A Conversation With Sandy Maguire - Melbourne Haskell Users' Group - 28-03-2024 In-Reply-To: References: Message-ID: Hi John, Thanks for recording the interview and uploading it for the benefit of the entire community. -- Kim-Ee On Sun, Feb 9, 2025 at 4:40 AM John Walker wrote: > > Hi All, > Our interview with Sandy Maguire at Melbourne Haskell Users' Group, (now > Melbourne Compose Group) is now on [YouTube](https://youtu.be/dnHIsr6gGnE > ). > > Sandy is well known in the Haskell and broader FP community, particularly > as the author of: > > - [Thinking With Types](https://leanpub.com/thinking-with-types) > - [Algebra Driven Design](https://leanpub.com/algebra-driven-design) > - [Certainty By Construction]( > https://leanpub.com/certainty-by-construction) > > John > > _______________________________________________ > Haskell-Cafe mailing list > To (un)subscribe, modify options or view archives go to: > http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe > Only members subscribed via the mailman list are allowed to post. -------------- next part -------------- An HTML attachment was scrubbed... URL: From vamchale at gmail.com Mon Feb 10 10:29:55 2025 From: vamchale at gmail.com (Vanessa McHale) Date: Mon, 10 Feb 2025 05:29:55 -0500 Subject: [Haskell-cafe] Course-of-value recursion by defining a sequence as a self-referential infinite list In-Reply-To: <4BA66911-6B17-4502-8179-B9D87E8A997F@gmail.com> References: <4BA66911-6B17-4502-8179-B9D87E8A997F@gmail.com> Message-ID: <6BC08DB6-15F5-47D6-BB78-BE73B931A42A@gmail.com> Looks like my attempt to paraphrase of Karczmarczuk’s solution skewered the performance. For efficiency it should be part = 1 : b 1 where b n = p where p = (1 : b (n + 1)) + (replicate n 0 ++ p) which is what is in Karczmarczuk’s paper (editing as necessary so replicate can be used as bxyn) > On Jan 22, 2025, at 7:01 AM, Vanessa McHale wrote: > > I came up with a one-liner for computing coefficients of the generating function for integer partitions: > > part :: Int → [Integer ] > part n = take n $ product [cycle (1 : replicate n 0) | n ← [0 . . (n − 2)]] > > Karczmarczuk’s solution via the Haskell prelude: > > part = 1 : b 1 > where b n = (1 : b (n + 1)) + (replicate n 0 ++ b n) > > cycle and replicate are really underrated! > >> On Jan 20, 2025, at 8:54 AM, Douglas McIlroy wrote: >> >> > catalanNumbers :: Num a => [a] >> > catalanNumbers = >> > let xs = 1 : PowerSeries.mul xs xs >> > in xs >> >> This example of a generating function come to life as a program deserves to be better known. Bill Burge presented it 50 years ago in "Recursive Programming Techniques", Addison-Wesley, 1975. I revisited it in "Power series, power serious", JFP 9 (1999) 323-335, where, with overloadied arithmetic, it became >> ts = 1 : ts^2 >> The technique is laid bare in ten one-liners at https://www.cs.dartmouth.edu/~doug/powser.html. >> >> Doug >> _______________________________________________ >> Haskell-Cafe mailing list >> To (un)subscribe, modify options or view archives go to: >> http://mail.haskell.org/cgi-bin/mailman/listinfo/haskell-cafe >> Only members subscribed via the mailman list are allowed to post. > -------------- next part -------------- An HTML attachment was scrubbed... URL: From zoran.bosnjak at via.si Sat Feb 15 12:51:36 2025 From: zoran.bosnjak at via.si (=?UTF-8?Q?Zoran_Bo=C5=A1njak?=) Date: Sat, 15 Feb 2025 13:51:36 +0100 Subject: [Haskell-cafe] using the same data structure on a type level and as a value Message-ID: <9a83719814e24814fe8ad6e6cc813640@via.si> Dear haskellers, I would like to reuse some (complex) data structures at a type level and as a regular value. The intention is to have the original specification on the type level (something like web API in Servant). But the idea is also to be able to convert the same structure to the value (of the same shape) and print it for example. There is no need to go from values back to types. I am not sure if Generic could help me do the conversion or do I need Typeable or even something else. I would like to avoid template haskell if possible, but please do advice if TH is the way to go in such cases. In my case, the data type structure is suppose to be the same, with the only difference being the 2 "primitives", which is: number is (Nat or Integer, depending on the usecase) and text is (Symbol or String). My attempt was something like this. import GHC.Generics -- not sure if this is required, but deriving works OK import GHC.TypeLits data Usecase = TypeLevel | ValueLevel -- Generic Int is 'Nat' or 'Integer'. type family GInt (u :: Usecase) where GInt 'TypeLevel = Nat GInt 'ValueLevel = Integer -- Generic Text is 'Symbol' or 'Text'. type family GText (u :: Usecase) where GText 'TypeLevel = Symbol GText 'ValueLevel = String -- Positive/zero or negative value. data PlusMinus = Plus | Minus deriving (Generic, Show) -- Now we can define generic plus/minus number. data PMInt (u :: Usecase) = PMInt PlusMinus (GInt u) deriving (Generic) deriving instance Show (PMInt 'ValueLevel) -- And we also define some more complex structure. data GNumber (u :: Usecase) = GNumInt (PMInt u) | GNumDiv (GNumber u) (GNumber u) | GNumPow (PMInt u) (PMInt u) deriving (Generic) deriving instance Show (GNumber 'ValueLevel) data GTest (u :: Usecase) = GTest [GInt u] [GText u] deriving (Generic) deriving instance Show (GTest 'ValueLevel) -- This does not work, but the idea is to define some type aliases -- In real application, this will be a huge list of structure descriptions (as types) type Example1 = 'PMInt 'Plus 3 -- GHC does not like '3' here?? type Example2 = 'PMInt 'Minus 4 type Example3 = 'GNumInt Example1 type Example4 = 'GNumDiv Example3 Example3 type Example5 = 'GTest '[ 1, 2, 3 ] '[ "Test1", "Test2"] -- 'convert' implementation ?? -- ... and be able to convert types to values, something like this val1 :: PMInt 'ValueLevel val1 = convert @Example1 -- ... or print it directly f :: IO () f = print ( convert @Example1, convert @Example2, convert @Example3 , convert @Example4, convert @Example5) Appreciate your suggestions. regards, Zoran From Graham.Hutton at nottingham.ac.uk Tue Feb 18 10:40:20 2025 From: Graham.Hutton at nottingham.ac.uk (Graham Hutton) Date: Tue, 18 Feb 2025 10:40:20 +0000 Subject: [Haskell-cafe] Midlands Graduate School - registration now open Message-ID: <5810DB1E-7460-49BA-BBC5-6AC4E42F3442@nottingham.ac.uk> Dear all, Registration is now open for the Midlands Graduate School (MGS) in the Foundations of Computing Science, 7-11 April 2025, Sheffield, UK. Eight fantastic courses on category theory, type theory, coalgebra, semantics and more. Spaces are limited, so please register early to secure your place. Please share in your communities! Best wishes, Graham Hutton ========================================================== Midlands Graduate School 2025 7-11 April 2025, Sheffield, UK https://tinyurl.com/MGS-2025 BACKGROUND: The Midlands Graduate School (MGS) in the Foundations of Computing Science provides an intensive course of lectures on the mathematical foundations of computing. The MGS has been running since 1999, and is aimed at PhD students in their first or second year of study, but the school is open to everyone, and has increasingly seen participation from industry. We welcome participants from all over the world! COURSES: Eight courses will be given. Participants usually take all the introductory courses and choose additional options from the advanced courses depending on their interests. Invited course - Four Lectures on Proof-theoretic Semantics, David Pym Introductory courses - Category Theory, Thorsten Altenkirch - The Curry-Howard Correspondence, Anupam Das - Quantum Computing, Venanzio Capretta Advanced courses - Coalgebra, Paul Blain Levy - Linear Logic, Abhishek De and Charles Grellois - Modular Proofs in Isabelle/HOL, Chelsea Edmonds - Refinement Types in Haskell, Brandon Hewer REGISTRATION: The registration fee is £300 for academic participants, and £500 for industry participants. The fee includes all lecture courses and example classes, lunch and coffee breaks. The registration deadline is ** Monday 17th March **. Spaces are limited, so please register early to secure your place. SPONSORSHIP: We offer a range of sponsorship opportunities for industry (bronze, silver, gold and platinum), each with specific benefits. Please see the website for further details. ========================================================== — Professor Graham Hutton School of Computer Science University of Nottingham, UK http://www.cs.nott.ac.uk/~pszgmh This message and any attachment are intended solely for the addressee and may contain confidential information. If you have received this message in error, please contact the sender and delete the email and attachment. Any views or opinions expressed by the author of this email do not necessarily reflect the views of the University of Nottingham. Email communications with the University of Nottingham may be monitored where permitted by law. From andrei.h.popescu at gmail.com Tue Feb 18 10:30:48 2025 From: andrei.h.popescu at gmail.com (Andrei Popescu) Date: Tue, 18 Feb 2025 10:30:48 +0000 Subject: [Haskell-cafe] Registration now open -- Re: Midlands Graduate School 2025 hosted by the University of Sheffield In-Reply-To: References: Message-ID: Dear Colleagues, Please note that the registration for the Midlands Graduate School is now open. You can access the registration site either from the MGS 2025 site (https://tinyurl.com/MGS-2025), or directly from here: https://onlineshop.shef.ac.uk/conferences-and-events/faculty-of-engineering/computer-science/midlands-graduate-school-in-the-foundations-of-computing-science-2025 Best wishes, Andrei On Mon, Feb 3, 2025 at 2:37 PM Andrei Popescu wrote: > > Dear Colleagues, > > This year's Midlands Graduate School in the Foundations of Computing > Science will take place at the University of Sheffield. We have some > great lecturers and topics. (Below you can also find information about > fees. The registration site will open soon.) > > Best wishes, > Andrei > > > Midlands Graduate School 2025 > > 7-11 April 2025, Sheffield, UK > > https://tinyurl.com/MGS-2025 > > > BACKGROUND > > The Midlands Graduate School (MGS) in the Foundations of > Computing Science provides an intensive course of lectures > on the mathematical foundations of computing. The MGS has > been running since 1999, and is aimed at PhD students in > their first or second year of study, but the school is open > to everyone, and has increasingly seen participation from > industry. We welcome participants from all over the world! > > COURSES > > Eight courses will be given. Participants usually take all > the introductory courses and choose additional options from > the advanced courses depending on their interests. > > Invited course > > - Four Lectures on Proof-Theoretic Semantics, David Pym > > Introductory courses > > - Category Theory, Thorsten Altenkirch > - The Curry-Howard Correspondence, Anupam Das > - Quantum Computing, Venanzio Capretta > > Advanced courses > > - Coalgebra, Paul Blain Levy > - Linear Logic, Abhishek De and Charles Grellois > - Modular Proofs in Isabelle/HOL, Chelsea Edmonds > - Refinement Types in Haskell, Brandon Hewer > > FEES AND REGISTRATION > > The fees for MGS 25, which also cover catering (including coffee, > pastries and lunch) during the day and optionally the conference > dinner, are as follows. > > - Academic participant: £300, plus an optional £30 dinner ticket for > Wednesday evening. > - Industry participant: £500, plus an optional £30 dinner ticket for > Wednesday evening. > > Registration will be open shortly. > > SPONSORSHIP > > We offer a range of sponsorship opportunities for industry (bronze, > silver, gold and platinum), each with specific benefits. Please see > the website for further details.