- Haskell-Cafe - Haskell.org

[ANN] data-forced 0.1.0.0 released!
by Ruben Astudillo 11 Apr '23

11 Apr '23

Hello everyone, I am excited to release the first version of data-forced 0.1.0.0. You can get it on <https://hackage.haskell.org/package/data-forced-0.1.0.0> <https://github.com/RubenAstudillo/data-forced> This is a library to avoid reference leaks (liveness leaks) on long lived data structures close to main. It does so without using explicit `seq` or bang patterns, instead using CBV functions, unlifted data type and tagging evaluated values with a unexported newtype constructor. It is a bang pattern you cannot forget! # The big idea We should not throw the information that a value was forced to WHNF or NF. We neither should be required to remember to put a `seq` or BangPattern at the use site to maintain this invariant. We accomplish this using two newtypes: - `newtype ForcedWHNF a = ForcedWHNF a` - `newtype ForcedNF a = ForcedNF a` that don't have their constructors exported. Only unidirectional patterns are provided so you can de-structure them. The *only* way to construct values of these types is via two CBVs functions: - strictlyWHNF :: forall a. a -> Strict (ForcedWHNF a) - strictlyNF :: forall a. NFData a => a -> Strict (ForcedNF a) The Strict data type is inspired by its analog on the data-elevator package <https://hackage.haskell.org/package/data-elevator>. It is a UnliftedDatatype, which means it cannot contain bottoms. The dynamic semantics of bound values of unlifted data types is that *before being bound, these are evaluated to WHNF*. It is a BangPattern you cannot forget! Once you obtain the `Strict (ForcedWHNF a)` value, you de-structurate it to obtain the *lifted* `ForceWHNF a` and store that. You are guaranteed that the references necessary to force it to WHNF are now free. Hopefully you will store it on a data structure that requires values to have been forced before like import Data.Map.Lazy type Accum1 = Map Char (ForcedWHNF Int) type Accum2 = Map Char (ForcedNF (Maybe Text)) # How to use it You should tag your long lived data structures with the correct type as in the previous example. It is less ergonomic than bang patterns, but you cannot forget to put them at the call site, parse not validate. import Data.Map.Lazy as ML -- Spine strict -- No references on added leafs even though it is a lazy map. basicEvent :: ML.Map Char (ForcedWHNF Int) -> IO (ML.Map Char (ForcedWHNF Int)) basicEvent map0 = do let val0 :: Strict (ForcedWHNF Int) -- val0 = strictlyWHNF (error "argument evaluated") -- would fail val0 = strictlyWHNF (2 + 2) -- CBV function, 2 + 2 reduced before val0 is bound. Strict val1 = val0 -- De-structure map1 = ML.insert 'a' val1 map0 pure map1 -- Same as before, but not references to values that were deleted and -- not forced. basicEventPromptDeletion :: Strict (ML.Map Char (ForcedNF (Maybe Int))) -> IO (Strict (ML.Map Char (ForcedNF (Maybe Int)))) basicEventPromptDeletion (Strict map0) = do -- map0 evaluated before being bound. let val0 :: Strict (ForcedNF (Maybe Int)) val0 = strictlyWHNF ((+1) <$> Just 28) Strict val1 = val0 -- De-structure map1 :: Strict (ML.Map Char (ForcedNF (Maybe Int))) -- forced when bound as map1 map1 = Strict (ML.insert 'a' val1 map0) pure map1 # Acknowledgment Sebastian Graf (sgraf812) should take all the credit. I was inspired by his data-elevator package that solves a sightly different problem. He infact pushed the proposal for unlifted data types and made the work to integrate them to GHC.

1 0

[ANN] Yampa 0.14.2, yampa-gloss 0.2.1, haskanoid 0.1.6, and more
by Ivan Perez 08 Apr '23

08 Apr '23

Hello everyone, I'm super excited to announce the release of Yampa 0.14.2! This release also comes with accompanying releases of many related projects: yampa-test (0.14.2), simple-affine-space (0.2.1), yampa-gloss (0.2.1), Space Invaders (0.14.2), and Haskanoid (0.1.6). Yampa is a fast, elegant Functional Reactive Programming implementation. Yampa prides itself in being a long-standing community project. It has now been around for 20 years!!! See https://github.com/ivanperez-keera/yampa#features for details on Yampa's features. This release has address mainly styling issues. All library code now conforms to the main rules of the style guide we follow (which is publicly documented). We've also addressed other minor maintenance issues, like compatibility with new versions of GHC and some dependencies, installation and CI issues, fixes to the README, and pointers to related community projects. In total, there have been more than 400 commits! Special thanks go to Miao ZhiCheng (@hellwolf) for a generous donation towards this release, and to @johannes-riecken for a regular contribution to support the Yampa project. All the projects listed above have been released in sync. For details, see: - https://github.com/ivanperez-keera/Yampa/releases/tag/v0.14.2 - https://github.com/ivanperez-keera/yampa-gloss/releases/tag/v0.2.1 - https://github.com/ivanperez-keera/simple-affine-space/releases/tag/v0.2.1 - https://github.com/ivanperez-keera/SpaceInvaders/releases/tag/v0.14.2 - https://github.com/ivanperez-keera/haskanoid/releases/tag/v0.1.6 You can explore the current versions at: - https://hackage.haskell.org/package/Yampa - https://hackage.haskell.org/package/yampa-test - https://hackage.haskell.org/package/yampa-gloss - https://hackage.haskell.org/package/simple-affine-space - https://hackage.haskell.org/package/SpaceInvaders - https://hackage.haskell.org/package/haskanoid *Code* The github repos are located at: - https://github.com/ivanperez-keera/Yampa/ - https://github.com/ivanperez-keera/yampa-gloss/ - https://github.com/ivanperez-keera/simple-affine-space/ - https://github.com/ivanperez-keera/SpaceInvaders/ - https://github.com/ivanperez-keera/haskanoid/ *What's coming* This release comes exactly 2 months after the last release. The next release is planned for Jun 7, 2023. There are several issues open that you can contribute in each project's issue tracker: Following our roadmap, the pending changes remain as follows: - Removal of unnecessarily exposed elements from the interface (e.g., FRP.Yampa.Arrow.arr3) that are not used and belong in other libraries. This topic is open to discussion. - Benchmarks: Facilitate making sound, evidence-based decisions about suggested improvements to the implementation, by completing a series of benchmarks. - New mailing list: We will in the future lose access to Yale's CS department-based mailman list, and are thinking of the best place to move the mailing list to. *Donations* Our project is now seeking donations to help continue developing Yampa, create new open source libraries, new material, and give talks. Github will match the first 5K donated, so if you donate $1/month, github will donate the same amount. No donation is too small. Any contribution will absolutely help. See https://github.com/sponsors/ivanperez-keera for details. If you can help, please come forward. All the best, Ivan

1 0

log, exp, (**), and non-negative real numbers
by Benjamin Redelings 04 Apr '23

04 Apr '23

Hi, I'm working with some classes that handle probabilities in terms of their log or log-odds. Such classes only handle non-negative real numbers. For example, from Numeric.Log: newtype Log a = Exp { ln :: a } Since the log of a positive number can be negative, we don't want to use the same type to hold the number and its logarithm. Standard functions exp, log, and (**) are awkward because they all assume that numbers and their powers have the same type: log,exp :: a -> a (**) :: a -> a -> a In comparison the ln function from Numeric.Log has a different signature that allows a number and its logarithm to have different types: ln :: Log a -> a Exp :: a -> Log a In order to address this, I have tried defining a type class Pow: class Fractional a => Pow a where pow :: a -> Double -> a ln :: a -> Double expTo :: Double -> a Probably I should replace "Double" here by a type variable b, but I have not done so yet. I'm mostly interested in abstracting over the type of non-negative number, because I have another type Prob that is designed to handle numbers like 1e - 100000, and 1.0 - 1e-100000. data Prob = Zero | Odds Double | One | IOdds Double | Infinity -- store probability in terms of log odds = log (p/(1-p)) Q1. Does anybody know of an existing Haskell module that implements something like the Pow class above? Also, it would be nice (notationally) if I could use log, exp, and (**) instead of ln, expTo, and pow. In theory we could factor out log, exp, (**), sqrt, and logBase from Floating into a new superclass of Floating, so that Floating only contains trig and hyper-trig functions. But I suspect this will not work because the methods in class Pow are more ambiguous. For example, if (x :: Double) then you can do (expTo x :: Prob) and (expTo x :: Log Double) and they will yield different types. Q2. Does anybody have a suggestion for a nicer design? Thanks! -BenRI

4 3

APLAS 2023 first Call for Papers
by Shin-Cheng Mu 04 Apr '23

04 Apr '23

====================================================================== CALL FOR PAPERS 21st Asian Symposium on Programming Languages and Systems (APLAS 2023) Taipei, Taiwan, Sun 26 – Wed 29 November 2023 https://conf.researchr.org/home/aplas-2023 ====================================================================== IMPORTANT DATES ------------------------------------- Submission deadline: Thu 15 Jun 2023 AoE Author response: Mon 31 Jul 12:00 - Wed 2 Aug 12:00 2023 AoE Author notification: Mon 14 Aug 2023 AoE Final paper deadline: Wed 6 Sep 2023 AoE Conference: Sun 26 – Wed 29 Nov 2023 SCOPE ------------------------------------- We solicit submissions in the form of regular research papers describing original scientific research results, including system development and case studies. Among others, solicited topics include: - ** programming paradigms and styles ** : functional programming; object-oriented programming; probabilistic programming; logic programming; constraint programming; extensible programming languages; programming languages for systems code; novel programming paradigms; - ** methods and tools to specify and reason about programs and languages ** : programming techniques; meta-programming; domain-specific languages; proof assistants; type systems; dependent types; program logics, static and dynamic program analysis; language-based security; model checking; testing; - ** programming language foundations ** : formal semantics; type theory; logical foundations; category theory; automata; effects; monads and comonads; recursion and corecursion; continuations and effect handlers; program verification; memory models; abstract interpretation; - ** methods and tools for implementation ** : compilers; program transformations; rewriting systems; partial evaluation; virtual machines; refactoring; intermediate languages; run-time environments; garbage collection and memory management; tracing; profiling; build systems; program synthesis; - ** concurrency and distribution ** : process algebras; concurrency theory; session types; parallel programming; service-oriented computing; distributed and mobile computing; actor-based languages; verification and testing of concurrent and distributed systems; - ** applications and emerging topics ** : programming languages and PL methods in education, security, privacy, database systems, computational biology, signal processing, graphics, human-computer interaction, computer-aided design, artificial intelligence and machine learning; case studies in program analysis and verification. GENERAL INFORMATION ------------------------------------- Submissions should not exceed 17 pages, excluding bibliography in the Springer LNCS format. LaTeX template is available at: https://www.springer.com/gp/computer-science/lncs/conference-proceedings-gu… The accepted papers will be allowed to use one extra page for the content to accommodate feedback from the reviews in the final paper versions. Papers should be submitted via HotCRP: https://aplas2023.hotcrp.com/ The review process of APLAS 2023 is double-anonymous, with a rebuttal phase. In your submission, please, omit your names and institutions; refer to your prior work in the third person, just as you refer to prior work by others; do not include acknowledgments that might identify you. Additional material intended for reviewers but not for publication in the final version - for example, details of proofs - may be placed in a clearly marked appendix that is not included in the page limit. Reviewers are at liberty to ignore appendices and papers must be understandable without them. Submitted papers must be unpublished and not submitted for publication elsewhere. Papers must be written in English. The proceedings will be published as a volume in Springer’s LNCS series. Accepted papers must be presented at the conference. POSTERS and STUDENT RESEARCH COMPETITION ---------------------------------------- APLAS 2023 includes a Posters session and a Student Research Competition. For more details, please see the website. https://conf.researchr.org/track/aplas-2023/posters-and-src ORGANIZERS ------------------------------------- General Chair: Shin-Cheng Mu, Academia Sinica, Taiwan Program Chair: Chung-Kil Hur, Seoul National University, Korea Publicity Chair: Ryosuke Sato, University of Tokyo, Japan Program Committee: Soham Chakraborty, TU Delft, Netherlands Yu-Fang Chen, Academia Sinica, Taiwan Ronghui Gu, Columbia University, USA Ichiro Hasuo, National Institute of Informatics, Japan Ralf Jung, ETH Zurich, Switzerland Ohad Kammar, University of Edinburgh, UK Jeehoon Kang, KAIST, Korea Jieung Kim, Inha University, Korea Robbert Krebbers, Radboud University Nijmegen, Netherlands Ori Lahav, Tel Aviv University, Israel Doug Lea, State University of New York at Oswego, USA Woosuk Lee, Hanyang University, Korea Hongjin Liang, Nanjing University, China Nuno P. Lopes, University of Lisbon, Portugal Chandrakana Nandi, Certora and UW, USA Liam O'Connor, The University of Edinburgh, UK Bruno C. d. S. Oliveira, The University of Hong Kong, Hong Kong Jihyeok Park, Korea University, Korea Clément Pit-Claudel, EPFL, Switzerland Matthieu Sozeau, Inria, France Kohei Suenaga, Kyoto University, Japan Tarmo Uustalu, Reykjavik University, Iceland John Wickerson, Imperial College London, UK Danfeng Zhang, Penn State University, USA

1 0

IFL23 first CFP
by Pieter Koopman 03 Apr '23

03 Apr '23

*Call for papers* The 35th Symposium on Implementation and Application of Functional Languages (IFL 2023) Braga, Portugal, August 29th-August 31st, 2023 *Important dates* Draft paper submission: July 31st, 2023 Draft paper notification: August 1st, 2023 Early registration deadline: August 11th, 2023 Late registration deadline: August 23rd, 2023 Symposium: August 29th - August 31st (3 days) *Scope* The goal of the IFL symposia is to bring together researchers actively engaged in the implementation and application of functional and function-based programming languages. IFL 2022 will be a venue for researchers to present and discuss new ideas and concepts, work in progress, and publication-ripe results related to the implementation and application of functional languages and function-based programming. Topics of interest to IFL include, but are not limited to: * language concepts * type systems, type checking, type inferencing * compilation techniques * staged compilation * run-time function specialization * run-time code generation * partial evaluation * abstract interpretation * metaprogramming * generic programming * automatic program generation * array processing * concurrent/parallel programming * concurrent/parallel program execution * embedded systems * web applications * embedded domain specific languages * security * novel memory management techniques * run-time profiling performance measurements * debugging and tracing * virtual/abstract machine architectures * validation, verification of functional programs * tools and programming techniques * industrial applications *Submissions and peer-review * Following IFL tradition, IFL 2023 will use a post-symposium review process to produce the formal proceedings. Before the symposium authors submit draft papers. These draft papers will be screened by the program chair to make sure that they are within the scope of IFL. The draft papers will be made available to all participants at the symposium. Each draft paper is presented by one of the authors at the symposium. Notice that it is a requirement that accepted draft papers are presented physically at the symposium. After the symposium, a formal review process will take place, conducted by the program committee. Reviewing is single blind. There will be at least 3 reviews per paper. The reviewers have 6 weeks to write their reviews. For the camera-ready version the authors can make minor revisions which are accepted without further reviewing. Contributions submitted for the draft paper deadline must be between two and twelve pages long. For submission details, please consult the IFL 2023 website at https://ifl23.github.io/ <https://ifl21-publicity-dot-yamm-track.appspot.com/2FXkDEWOUAQ2Tbyu5BN0P9Im…> . *Where * IFL 2023 will be held physically in Braga, Portugal, arranged by University of Minho. See the IFL 2023 website at https://ifl23.github.io/ <https://ifl21-publicity-dot-yamm-track.appspot.com/2vSkCLOx6DJpj_Yo1M1_gXPf…> for more information. [image: beacon]

1 0

GPT & Haskell
by Gregory Guthrie 02 Apr '23

02 Apr '23

>From a colleague: GPT Pretty smart(?!). But this is of course simple, and searchable. Still... -------------------------------------------------------------------------------------------------- GPT-4 when prompted: Write binary search in Haskel. Print results using putStrLn. Ensure bug-free code by specifying preconditions, postconditions, invariants, variants, internal states. gives the following response: -- Binary search in Haskell -- Precondition: the list is sorted in ascending order -- Postcondition: the function returns the index of the target element if found, or Nothing otherwise -- Invariant: the search space is always within the bounds of the list -- Variant: the search space decreases by half at each recursive call -- Internal state: the lower and upper bounds of the search space binarySearch :: Ord a => [a] -> a -> Maybe Int binarySearch xs x = go xs x 0 (length xs - 1) where go xs x lo hi | lo > hi = Nothing -- base case: search space is empty | x == midElem = Just mid -- base case: target element is found | x < midElem = go xs x lo (mid - 1) -- recursive case: search in the left half | otherwise = go xs x (mid + 1) hi -- recursive case: search in the right half where mid = (lo + hi) `div` 2 -- calculate the middle index midElem = xs !! mid -- get the middle element -- Print results using putStrLn main :: IO () main = do let xs = [1, 3, 5, 7, 9] -- a sorted list of integers let x = 5 -- a target element to search for let result = binarySearch xs x -- call the binary search function case result of -- pattern match on the result Nothing -> putStrLn "Element not found" -- print a message if Nothing is returned Just i -> putStrLn $ "Element found at index " ++ show i -- print a message with the index if Just i is returned The above code runs: https://onecompiler.com/cpp/3z48yt2pp [cid:image001.png@01D963E1.B0EB6AB0]

20 38

Re: [Haskell-cafe] GPT & Haskell
by Aloïs Cochard 01 Apr '23

01 Apr '23

Thanks for fixing the link Nenad, I leave you with an excerpt from Oleg's last paper which contains that beautiful quote: ``This make me think that the authors are under the impression that compilers can magically transform bad code into efficient high-quality code by clever enough optimizations. As a compiler writer, I consider this a complete myth that many students and non-compiler-developers hope is a truth. I agree that compilers should aim to improve the efficiency of the code given as input, but one cannot expect the compiler to recognize algorithms and swap them for ones with better asymptotic complexity or *make other major code transformations that really should be the job of the programmer*. [emphasis mine]'' Magnus Myreen. On Sat, 1 Apr 2023 at 18:06, Nenad Končar <nlpresearcher(a)gmail.com> wrote: > GPT-4 when prompted with an improved prompt: > > *Write binary search in Haskel. Print results using putStrLn. Ensure > bug-free code by specifying preconditions, postconditions, invariants, > variants and internal states. Calculate the middle index using a safer > formula to avoid intermediate overflow.* > > > > gives the following response: > > *-- Binary search is a recursive algorithm that finds an element in a > sorted list by* > > *-- repeatedly dividing the list into two halves and comparing the element > with the middle value.* > > *-- It returns the index of the element if found, or Nothing otherwise.* > > > > *-- Precondition: The input list must be sorted in ascending order.* > > *-- Postcondition: The output index must be within the bounds of the list > and point to the element, or be Nothing.* > > *-- Invariant: The element, if present, must be in the current sublist.* > > *-- Variant: The length of the current sublist decreases by half at each > recursive call.* > > *-- Internal state: The current sublist is defined by two indices: low and > high.* > > > > *binarySearch :: Ord a => [a] -> a -> Maybe Int* > > *binarySearch xs x = go xs x 0 (length xs - 1)* > > * where* > > * -- The go function performs the recursive search on the sublist > [low..high].* > > * go :: Ord a => [a] -> a -> Int -> Int -> Maybe Int* > > * go xs x low high* > > * -- Base case 1: The sublist is empty, so the element is not found.* > > * | low > high = Nothing* > > * -- Base case 2: The middle value is equal to the element, so the > index is found.* > > * | xs !! mid == x = Just mid* > > * -- Recursive case 1: The element is smaller than the middle value, > so search in the left half.* > > * | x < xs !! mid = go xs x low (mid - 1)* > > * -- Recursive case 2: The element is larger than the middle value, > so search in the right half.* > > * | otherwise = go xs x (mid + 1) high* > > * where* > > * -- Calculate the middle index using a safer formula to avoid > overflow.* > > * mid = low + (high - low) `div` 2* > > > > *-- A sample list to test the binary search function.* > > *sampleList :: [Int]* > > *sampleList = [1, 3, 5, 7, 9, 11, 13, 15]* > > > > *-- A sample element to search for in the list.* > > *sampleElement :: Int* > > *sampleElement = 9* > > > > *-- Print the result of the binary search using putStrLn.* > > *main :: IO ()* > > *main = do* > > * let result = binarySearch sampleList sampleElement* > > * case result of* > > * Nothing -> putStrLn "Element not found."* > * Just i -> putStrLn $ "Element found at index " ++ show i ++ "."* > > The above code runs: > *https://onecompiler.com/haskell/3z4c7f5dt > <https://onecompiler.com/haskell/3z4c7f5dt>* > > > Furthermore, GPT-4 when prompted: > > *For the binary search algorithm, list all possible preconditions, > postconditions, invariants, variants, internal states, underflows, > overflows, divisions by zero, mistakes, errors, bugs, run-time exceptions, > faults, defects and pitfalls.* > > and then prompting GPT-4 again with: > > *Summarize the following:* > > *<result from the previous prompt given to * *GPT-4* > *>* > > gives the following response: > > *Hi there,* > > *I hope this email finds you well. I am writing to summarize the > following:* > > > > > > > > > > > *- The algorithm searches for a target value in a sorted array using > binary search. - The algorithm returns the index of the target value in the > array or -1 if the target value is not found. - The algorithm does not > modify the input array. - The algorithm assumes that the input array is > sorted in ascending or descending order, the target value is comparable > with the elements of the array, and the lower and upper bounds of the > search range are valid indices of the array. - The algorithm maintains the > invariant that the target value is always within the search range or does > not exist in the array. - The algorithm reduces the size of the search > range by at least one after each iteration. - The algorithm handles edge > cases such as empty array, single element array, target value at the first > or last position of the array, lower and upper bounds being equal, negative > or large positive integers, and division by zero when calculating the > middle index. - The algorithm avoids integer underflow or overflow when > calculating the middle index by using bitwise operations instead of > arithmetic operations. - The algorithm has been tested with various test > cases to ensure its correctness and efficiency. - The algorithm has been > verified using formal methods to prove its preconditions, postconditions, > invariants and variants.* > *Please let me know if you have any questions or feedback about the > algorithm. I appreciate your time and attention.* > > > The following web pages provide some credence to GPT-4's claim of > avoiding overflows/underflows by using bitwise operations instead of > arithmetic operations: > > https://stackoverflow.com/questions/10078778/bitwise-overflow-checking-in-c > > https://www.opensourceforu.com/2009/03/joy-of-programming-how-to-detect-int… > > The truth is that bitwise operations can recognise if an overflow is about > to happen prior to it happening. I do not see how bitwise operations can > *avoid* overflow and therefore GPT-4's claim in this case, in my humble > view, should be classified as it having a *vivid imagination*. > > > > > > > On Sat, 1 Apr 2023 at 16:11, Nenad Končar <nlpresearcher(a)gmail.com> wrote: > >> Here is the correct link to Haskel code: >> >> https://onecompiler.com/haskell/3z4c7f5dt >> >> On Sat, 1 Apr 2023 at 15:42, Gregory Guthrie <guthrie(a)miu.edu> wrote: >> >>> Yes, will check on it. >>> >>> >>> >>> That is because the reason that a simple program was used was because >>> the example was to ask GPT to solve it is a range of languages, one of >>> which was Haskell and there were links to solutions in all of them.. >>> >>> >>> >>> “*Write binary search in xxxx. Ensure bug-free code by specifying >>> preconditions, postconditions, invariants, variants, internal states.”* >>> >>> >>> >>> { HTML, CSS and JavaScript, C++, Haskell, JavaScript, Python, >>> CommonLisp, C, C#, PHP, Java, Go, Erlang, Alloy, TLA+, X-Machine, PVS >>> Verifier, SPIN model checker, Guarded Command Language, Hoare triples, >>> Gries & Owicki concurrent code} >>> >>> >>> >>> It was an interesting exercise from Dr. Nenad Koncar, a successful NL >>> researcher and developer. I’ll ask him for a corrected link to the Haskell >>> version. >>> >>> >>> >>> Dr. Gregory Guthrie >>> >>> >>> >>> *From:* Aloïs Cochard <alois.cochard(a)gmail.com> >>> *Sent:* Saturday, April 1, 2023 8:23 AM >>> *To:* Gregory Guthrie <guthrie(a)miu.edu> >>> *Cc:* haskell-cafe(a)haskell.org; Nenad Končar <nlpresearcher(a)gmail.com>; >>> Haskell Community < >>> replies+f6607596e3ee63f105e2b0327b86f062(a)discourse.haskell.org> >>> *Subject:* Re: [Haskell-cafe] GPT & Haskell >>> >>> >>> >>> Dear Gregory, >>> >>> >>> >>> Can you please fix your onecompiler vanity link? It points to the C++ >>> runtime implementation. >>> >>> >>> >>> Thanks >>> >>> >>> >>> On Fri, 31 Mar 2023 at 22:04, Gregory Guthrie <guthrie(a)miu.edu> wrote: >>> >>> From a colleague: >>> >>> GPT Pretty smart(?!). >>> >>> But this is of course simple, and searchable. >>> >>> >>> >>> Still… >>> >>> >>> -------------------------------------------------------------------------------------------------- >>> >>> GPT-4 when prompted: >>> >>> *Write binary search in Haskel. Print results using putStrLn. Ensure >>> bug-free code by specifying preconditions, postconditions, invariants, >>> variants, internal states.* >>> >>> >>> >>> gives the following response: >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> >>> *-- Binary search in Haskell -- Precondition: the list is sorted in >>> ascending order -- Postcondition: the function returns the index of the >>> target element if found, or Nothing otherwise -- Invariant: the search >>> space is always within the bounds of the list -- Variant: the search space >>> decreases by half at each recursive call -- Internal state: the lower and >>> upper bounds of the search space binarySearch :: Ord a => [a] -> a -> Maybe >>> Int binarySearch xs x = go xs x 0 (length xs - 1) where go xs x lo hi >>> | lo > hi = Nothing -- base case: search space is empty | x == >>> midElem = Just mid -- base case: target element is found | x < >>> midElem = go xs x lo (mid - 1) -- recursive case: search in the left half >>> | otherwise = go xs x (mid + 1) hi -- recursive case: search in the >>> right half where mid = (lo + hi) `div` 2 -- calculate the >>> middle index midElem = xs !! mid -- get the middle element -- Print >>> results using putStrLn main :: IO () main = do let xs = [1, 3, 5, 7, 9] >>> -- a sorted list of integers let x = 5 -- a target element to search for >>> let result = binarySearch xs x -- call the binary search function case >>> result of -- pattern match on the result Nothing -> putStrLn "Element >>> not found" -- print a message if Nothing is returned Just i -> putStrLn >>> $ "Element found at index " ++ show i -- print a message with the index if >>> Just i is returned* >>> >>> >>> >>> The above code runs: >>> >>> *https://onecompiler.com/cpp/3z48yt2pp >>> <https://onecompiler.com/cpp/3z48yt2pp>* >>> >>> _______________________________________________ >>> 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. >>> >>> >>> >>> -- >>> >>> *Λ\oïs* >>> >>> http://twitter.com/aloiscochard >>> >>> http://github.com/aloiscochard >>> >> -- *Λ\oïs* http://twitter.com/aloiscochard http://github.com/aloiscochard

1 0

Re: [Haskell-cafe] GPT & Haskell
by Gregory Guthrie 31 Mar '23

31 Mar '23

---------- Forwarded message ---------- From: "Nenad Končar" <nlpresearcher(a)gmail.com<mailto:nlpresearcher@gmail.com>> To: Levent Erkok <erkokl(a)gmail.com<mailto:erkokl@gmail.com>> Cc: Gregory Guthrie <guthrie(a)miu.edu<mailto:guthrie@miu.edu>>, "haskell-cafe(a)haskell.org<mailto:haskell-cafe@haskell.org>" <haskell-cafe(a)haskell.org<mailto:haskell-cafe@haskell.org>>, Haskell Community <replies+f6607596e3ee63f105e2b0327b86f062(a)discourse.haskell.org<mailto:replies%2Bf6607596e3ee63f105e2b0327b86f062@discourse.haskell.org>> Bcc: Date: Sat, 1 Apr 2023 00:00:09 +0200 Subject: Re: [Haskell-cafe] GPT & Haskell On Fri, 31 Mar 2023 at 23:24, Levent Erkok <erkokl(a)gmail.com<mailto:erkokl@gmail.com>> wrote: This code is buggy when lo + hi overflows your integer type. Classic (extremely) corner case bug: https://ai.googleblog.com/2006/06/extra-extra-read-all-about-it-nearly.html Thank you kindly for pointing this out. GPT-4, when prompted, is able to detect and correct the overflow mistake as follows: After I introduced a purposeful mistake in the Haskel code, I prompted GPT-4 as follows: If the following Haskel code contains any logical mistakes then correct the code for me: -- Binary search in Haskell -- Precondition: the list is sorted in ascending order -- Postcondition: the function returns the index of the target element if found, or Nothing otherwise -- Invariant: the search space is always within the bounds of the list -- Variant: the search space decreases by half at each recursive call -- Internal state: the lower and upper bounds of the search space binarySearch :: Ord a => [a] -> a -> Maybe Int binarySearch xs x = go xs x 0 (length xs - 1) where go xs x lo hi | lo > hi = Nothing -- base case: search space is empty | x == midElem = Just mid -- base case: target element is found | x < midElem = go xs x lo (mid - 1) -- recursive case: search in the left half | otherwise = go xs x (mid + 1) hi -- recursive case: search in the right half where mid = (lo - hi) `div` 2 -- calculate the middle index midElem = xs !! mid -- get the middle element -- Print results using putStrLn main :: IO () main = do let xs = [1, 3, 5, 7, 9] -- a sorted list of integers let x = 5 -- a target element to search for let result = binarySearch xs x -- call the binary search function case result of -- pattern match on the result Nothing -> putStrLn "Element not found" -- print a message if Nothing is returned Just i -> putStrLn $ "Element found at index " ++ show i -- print a message with the index if Just i is returned and then GPT-4 replied: Hello, Thank you for sending me your Haskell code for binary search. I appreciate your interest in learning this functional programming language. I have reviewed your code and found a few logical mistakes that need to be corrected. Here is the revised code with some comments explaining the changes: -- Binary search in Haskell -- Precondition: the list is sorted in ascending order -- Postcondition: the function returns the index of the target element if found, or Nothing otherwise -- Invariant: the search space is always within the bounds of the list -- Variant: the search space decreases by half at each recursive call -- Internal state: the lower and upper bounds of the search space binarySearch :: Ord a => [a] -> a -> Maybe Int binarySearch xs x = go xs x 0 (length xs - 1) where go xs x lo hi | lo > hi = Nothing -- base case: search space is empty | x == midElem = Just mid -- base case: target element is found | x < midElem = go xs x lo (mid - 1) -- recursive case: search in the left half | otherwise = go xs x (mid + 1) hi -- recursive case: search in the right half where mid = lo + (hi - lo) `div` 2 -- calculate the middle index using a safer formula to avoid overflow midElem = xs !! mid -- get the middle element -- Print results using putStrLn main :: IO () main = do let xs = [1, 3, 5, 7, 9] -- a sorted list of integers let x = 5 -- a target element to search for let result = binarySearch xs x -- call the binary search function case result of -- pattern match on the result Nothing -> putStrLn "Element not found" -- print a message if Nothing is returned Just i -> putStrLn $ "Element found at index " ++ show i -- print a message with the index if Just i is returned The main mistake in your code was in the calculation of the middle index. You used `(lo - hi) `div` 2`, which is incorrect because it will always give a negative value. The correct formula is `lo + (hi - lo) `div` 2`, which ensures that the middle index is always within the bounds of the list. This formula also avoids overflow issues that might occur if you use `(lo + hi) `div` 2`. I hope this helps you understand binary search better and improve your Haskell skills. Please let me know if you have any questions or feedback. I would love to hear from you and help you further. Happy coding! The improved code runs: https://onecompiler.com/haskell/3z4avpx6n On Mar 31, 2023, at 1:02 PM, Gregory Guthrie <guthrie(a)miu.edu<mailto:guthrie@miu.edu>> wrote: From a colleague: GPT Pretty smart(?!). But this is of course simple, and searchable. Still… -------------------------------------------------------------------------------------------------- GPT-4 when prompted: Write binary search in Haskel. Print results using putStrLn. Ensure bug-free code by specifying preconditions, postconditions, invariants, variants, internal states. gives the following response: -- Binary search in Haskell -- Precondition: the list is sorted in ascending order -- Postcondition: the function returns the index of the target element if found, or Nothing otherwise -- Invariant: the search space is always within the bounds of the list -- Variant: the search space decreases by half at each recursive call -- Internal state: the lower and upper bounds of the search space binarySearch :: Ord a => [a] -> a -> Maybe Int binarySearch xs x = go xs x 0 (length xs - 1) where go xs x lo hi | lo > hi = Nothing -- base case: search space is empty | x == midElem = Just mid -- base case: target element is found | x < midElem = go xs x lo (mid - 1) -- recursive case: search in the left half | otherwise = go xs x (mid + 1) hi -- recursive case: search in the right half where mid = (lo + hi) `div` 2 -- calculate the middle index midElem = xs !! mid -- get the middle element -- Print results using putStrLn main :: IO () main = do let xs = [1, 3, 5, 7, 9] -- a sorted list of integers let x = 5 -- a target element to search for let result = binarySearch xs x -- call the binary search function case result of -- pattern match on the result Nothing -> putStrLn "Element not found" -- print a message if Nothing is returned Just i -> putStrLn $ "Element found at index " ++ show i -- print a message with the index if Just i is returned The above code runs: https://onecompiler.com/cpp/3z48yt2pp <image001.png> _______________________________________________ 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.

1 0

[Haskell] [ANNOUNCE] Haskell Language Server 1.10.0.0 released
by Zubin Duggal 31 Mar '23

31 Mar '23

Binaries for this release are available at https://downloads.haskell.org/~hls/haskell-language-server-1.10.0.0/. These binaries can be installed using [GHCup](https://www.haskell.org/ghcup/) or version [2.0.0 and above](https://github.com/haskell/vscode-haskell/releases) of the VSCode extension. Older versions of the VSCode extension will not attempt to download this version. # Changelog - Support for GHC 9.6 - Binaries for GHC 9.2.7 and GHC 9.6.1 - Eval plugin support for GHC 9.4+ (#3391) - Don't show lenses for TH generated instances when using hls-class-plugin (#3531) For the full release notes, see https://github.com/haskell/haskell-language-server/releases/tag/1.10.0.0 Happy editing! - Zubin

2 1

Munich Haskell Meeting, 2023-03-29 @ 19:30
by Leah Neukirchen 27 Mar '23

27 Mar '23

Dear all, This week, our monthly Munich Haskell Meeting will take place again on Wednesday, March 29 at Augustiner-Gaststätte Rumpler at 19h30. For details see here: http://muenchen.haskell.bayern/dates.html If you plan to join, please add yourself to this nuudel so we can reserve enough seats! It is OK to add yourself to the dudle anonymously or pseudonymously. https://nuudel.digitalcourage.de/21as1kuu1eUg8qTt Everybody is welcome! cu, -- Leah Neukirchen <leah(a)vuxu.org> https://leahneukirchen.org/

2 1