> This presentation was recorded at YOW! 2019. #GOTOcon #YOW > https://yowcon.com > > Philip Wadler - Professor at University of Edinburgh ‪@philipwadler‬ > > RESOURCES > / philip-wadler-a2bb3a276 > https://github.com/wadler > https://homepages.inf.ed.ac.uk/wadler > https://wadler.blogspot.com > > ABSTRACT > The most profound connection between logic and computation is a pun. The doctrine of Propositions as Types asserts that propositions correspond to types, proofs to programs, and simplification of proofs to evaluation of programs. The proof of a conjunction is a pair, the proof of a disjunction is a case expression, and the proof of an implication is a lambda expression. Proof by induction is just programming by #recursion. > > Dependently-typed #ProgrammingLanguages, such as #Agda, exploit this pun. To prove properties of programming languages in Agda, all we need do is program a description of those languages Agda. Finding an abstruse mathematical proof becomes as simple and as fun as hacking a program. This talk introduces Programming Language Foundations in Agda, a new textbook that is also an executable #AgdaScript---and also explains the role Agda is playing in #IOHK's new cryptocurrency. [...] > > RECOMMENDED BOOKS > Rebecca Skinner • Effective Haskell • https://amzn.to/3SxTpwY > Vitaly Bragilevsky • Haskell in Depth • https://amzn.to/3EXpmbe > > / gotocon > / goto- > / goto_con > / gotoconferences > #SoftwareEngineering #Programming #Haskell #SoftwareDevelopmentTutorial #ProgrammingTutorial #FunctionalProgramming #PhilipWadler #YOWcon > > Looking for a unique learning experience? > Attend the next GOTO conference near you! Get your ticket at https://gotopia.tech > Sign up for updates and specials at https://gotopia.tech/newsletter > > SUBSCRIBE TO OUR CHANNEL - new videos posted almost daily. > https://www.youtube.com/user/GotoConf...

> Advait Shinde discusses the history of the theory of computation, delving into axiomatic thinking, Peano axioms, Turing Machines, Lambda Calculus, the Y Comb...

cross-posted from: https://sopuli.xyz/post/10354955

> If "category" has a better name.... > > Isn't it just "composite"? > > Every arrow in category can be composed, the set(or class or whatnot..) of that is composite.

cross-posted from: https://sopuli.xyz/post/9969591

> Understanding the Type of call/cc > > He introduces but also criticizes the use of call/cc, 1. not being a function and looks like a function, 2. able to produce an union of types with it. > > Is he correct? What do you think?

I've been enjoying learning ocaml, but I found it very easy to write code riddled with side effects and imperative-ness.

Take this example:

let some_func arg = let input = format_input_from_stdin () let read_content = read_file "some/file/path.txt" let to_write = get_write_file_content input read_content let () = write_file "some/other/path.txt" to_write let output = run_external_command_with_output (output, read_content)

As you can see, many side effects and imperative steps in the code. Is there a better practice for coding this in a functional manner?

I just started to learn Ocaml to learn functional programming. I will use it to build a CLI that's mostly orchestrating other programs.

My experience is mostly in JS / TS, but I've also coded a good bit in Python and Lua.

Below, I provided a list of things I learned or focused on while using OCaml. But I feel like I must be missing something. This is only moderately different from what I'm used to in JS. I expected something more radical. Moreover, I constantly hear a lot of FP jargon (like "highly kinded types", monads, etc) that I feel am still missing.

So far, here's what I studied:

• immutability
• avoid side affects
• static typing
• recursion instead of loops
• option / maybe
• higher order functions
• conditionals and other constructs as expressions, when they're statements in other languages
• pipelines and functions as input —> output
• currying
• scoping with let

What am I missing?

A podcast with transcript which may help explain fp to laymen.

Hello fellow FP-Lemmyites. I'd love to hear stories about what got you interested in FP originally, and how you learned.

In part one, we discussed how OCaml’s locality mode enables safe stack allocation. In this post, we will explore additional modes for representing ownership.

https://blog.janestreet.com/oxidizing-ocaml-ownership/

My first language was Racket and so naturally I gravitated to the lispy untyped functional programming style even when I was using languages like Python or Java, but when I tried Haskell for the first time my mind was absolutely blown and I was a convert ever since. What are your thoughts?

I'd love to hear more about it. I'm a new grad who's done a bunch of internships using functional programming languages but didn't find a new grad position that does

Howdy, I remember a podcast where they have the example of Microsoft Excel as an example for an introduction to functional programming. I believe it was an SE Radio podcast on Clojure or that build tool it uses. It doesn't really matter.

I already understood functional concepts and try to use them where I can in Java and other languages. (It is easier to reason about immutable data and pure methods.) I found the metaphor of Excel very interesting though. Because that's basically what it is. I'm sure there are ways to have it not act functionally but the vast majority of the time it is, and I think more people have the basic vocabulary of Excel than functional programming.

Has anyone ever used this or heard of it being used as an example while teaching fp?

Rofi-Hoogle is a tool I wrote a couple of years ago to scratch a particular itch: I was often wanting to quickly remind myself of the name or types of functions while writing, and I didn't always want to search Hoogle or spin up a repl to figure out what I needed. I was already using rofi to quickly reference other information, so I decided to build an integration to let me reference a local hoogle DB with a single keystroke directly from my desktop.

FP is a big umbrella with a lot of interesting work happening. Let's help one-another stay up-to-date by sharing links of some of our favorite FP and FP-adjacent talks.

Hi everyone. I thought I'd kick off the functional programming community here by sharing an article from my own blog on Haskell's fixed point function.