As in title, I would appreciate any reccomendation.

👋 Hey guys, so I'm fairly new to the whole Cardano developer ecosystem. I am currently learning solidity and its in and outs. I have recently began reading on the workings of cardano, its academic background and foundation and believe it has potential to be a great blockchain if not the best if more developers hop on board.

So as a result I'm interested in learning how to develop cardano dapps, I know that Haskell is a non conditional prerequisite that one must learn to enter this space. What I would like to know is how much Lambda Calculus is truly need for me to know in order to create full functioning quality Dapps with Haskel. I will admit im not the strongest in math but I am capable of learning lambda if need be, I just need to know if it's something I MUST know in order to be a functional cardano dev.

thanks in advance for any responses.

I am going through Haskell from First Principals and it starts off with lambda calculus. I don't quite understand it and am wondering how crucial it is to know lambda calculus forwards and backwards. For example should I read this book first? Introduction to Functional Programming Through Lambda Calculus

0 in lambda calculus is λfa.a which is shorthand for λf.(λa.a) if I'm not mistaken. λa.a is the identity, I, so 0 in lambda calculus is λf.I. Is this correct?

Hi, I'm working on a lambda calculus interpreter that compiles to WebAssembly. Try it online here.

It has optimizations to avoid recomputing shared subexpressions, so even very large expressions are fairly quick to evaluate. It also simplifies the output of evaluating expressions, by expressing the output in terms of already-defined functions/values where possible.

Right now it only includes a couple of built-in definitions, and the UI isn't as good as it could be. And although it saves your changes in local storage, there's currently no way to import/export definitions. I doubt this is currently very useful, but hopefully it's still fun to play around with.

I watched a talk on lambda calculus at a Python conference and was fascinated (https://www.youtube.com/watch?v=pkCLMl0e_0k .. warning, three hours long). Is it an active area of research or is it completely solved? What open questions remain?

I was playing around with the calculus of construction's typing rules and I realized you could modify them a bit to reuse the lambda term's type checking rules to type check a forall.

https://preview.redd.it/meg797hlrm271.png?width=2550&format=png&auto=webp&s=8a7ed621e5e8f385c4eedb94f0cfd890c683a836

Has this been discovered before? Could this be useful in any way?

• First, if it's only about typing, why is the control operator needed at all? If \alpha is of type \neg A, and \neg A means A \implies \bot, why can't I just write \alpha A for the same result, i.e. evaluating to \bot?
• Second, why is \lambda x.\mu \pi.x \mu not enough to proof \neg \neg P \implies P?

LambFuck

So I had this idea for an esoteric programming language. It's not exactly a complex idea, but I have a rough idea of the semantics. Let me know if there's anything I missed, or that you think I should add.

So we have all the features of lambda calculus, which (if I'm remembering correctly) are:

• Variables - which can be letters or words or even numbers, because we don't have those in lambda calculus.
• Abstraction - this is our function definitions, which can use variables as parameters
• Application - this is our function calls, how we apply functions to arguments

So I'm probably not 100% on that, so feel free to clear up in comments.

Right, onto language semantics.

We have a simplified (I know, simpler than 8?) Set of the brainfuck characters:

• ">" - increments the data pointer
• "<" - decrements the data pointer
• "+" - increments the byte at the data pointer
• "-" - decrements the byte at the data pointer
• "!" - outputs the byte at the data pointer (edited)
• "?" - stores 1 input byte at the data pointer (tweaked from "," because that's needed later) (edited)
• "_" - checks if the byte at the data pointer is 0, and returns TRUE (\x, y: x) if it equals 0, or FALSE (\x, y: y) if it doesn't.

All of the brainfuck operators (with the exception of "_") are lambda functions that take one parameter, perform their intended side effect, then return the given parameter. So in a sense they are the function Identity function (\x: x) but they perform side effects.

That's the brainfuck stuff out the the way. We don't have the angle brackets "[" and "]" because lambda calculus can perform recursion, so the loops with them aren't required.

Now for lambda calculus semantics. Sticking within the theme of brain fuck, let's make them all single characters:

• "\" - indicates the definition of a function
• ":" - indicates the end of the parameter list
• ";" - defines the end of a function definition
• "=" - used to assign functions to variables
• "#" - defines a comment
• "(" & ")" - used to disambiguate variables in function application.

White space is used as a separator for parameters in a function definition, and those passed into a function.

So, that's pretty much it. 14 symbols and a functional programming language. Note that as with lambda calculus, alpha conversion and beta reduction would be performed. But that would likely be done by the compiler, unless you wish to do it manually at the time of writing.

In terms of use

What other benefits other than understanding concepts do you guys get? Does it increase your productivity in any way?

Lambda calculus is the foundation of functional languages, in the sense that it can almost be seen as a subset of a functional language, up to minor syntactic change.

Lambda calculus is also a model of computation, according to https://en.wikipedia.org/wiki/Model_of_computation.

Is there a model of computation which has similar influence to imperative languages, as Lambda calculus to functional languages?

• Turing machine is used for computability study. Is writing a program on a universal Turing machine like writing a program in a procedural language?

• RAM is used for complexity study. Does it have the same influence to procedural imperative languages as Lambda calculus to functional languages?

Thanks.

I’m a software developer, and I want to get a small tattoo of a lowercase Greek letter Lambda (no color) to represent an anonymous function. I’m open to it being all black, or have or some interesting shading or geometry, but I want the overall image to be relatively triangular (so no circle background or anything).

Bonus: lambdas also represent gay pride, and my friend wants to get a rainbow one when I get my black one. I’d love to see some creative stuff! Obviously simplicity is key but I’m open to ideas here. We’re talking one (or two) small, simple tattoos so no need for anything crazy.

As much as i read and try to understand Lambda Calculus i just can’t. Can someone explain it to me in the most simple way to at least understand the basics of it :D

I have written a little paper:

Programming in Lambda Calculus

The text looks at lambda calculus from a programmers point of view. Everyone with some programming experience should be able to read and understand the text.

Special effort is given on how to represent algebraic data types in lambda calculus.

I hope some of you might enjoy the paper.

In most literature explaining functional programming that I have read it is often stated that functions in Haskell are mathematical functions. That the notion of function as it is in Haskell is what exist in mathematics (this is done to differentiate from methods/procedures).

It is also stated that Haskell is an implementation of the lambda calculus.

I am not a mathematician but I am aware that functions in mathematics can be derived from set theory. Where a function is a mapping of values from a set called domain to another set called codomain. This then leads to 3 categories of functions: Surjective, Injective and Bijective

Also from the simplified explanation of Lambda calculus that I have read, it is stated that The lambda calculus has three basic components, or lambda terms:expressions, variables, and abstractions. Where abstractions is similar to the knowing of a function.

The question now is...is abstraction as defined in Lambda calculus one and the same as function as arrived via set theory. I am not sure as the few explanation of Lambda calculus I have read did not clarify this if this relationship exist or not. For example in materials I have read it is not explicitly stated if the abstraction in lambda calculus enforces the constraints that says x can map to one and only one y

Thoughts?

Hey everyone!

This is a project I worked on during the start of the summer, and after some rewrites of the front end I think it's in a good enough state to share with people. The interpreter is written in TypeScript and is my first major PL project, so if you have constructive criticism/advice I'd appreciate it. If you want to play around with the interpreter, it's available to try on lambster.dev or you can use the CLI by installing it via npm.

Please let me know what you think. Thanks!

Links:

Lambster: https://lambster.dev

Interpreter source: https://github.com/minchingtonak/lambster

Website source: https://github.com/minchingtonak/lambster.dev

So i had an exam a few days ago and this problem was on it. I failed it and i do not have a solution for it and would like some help to understand how to solve it step by step. I am familiar with how beta reduction works, but this particular problem just gives me a headache:

(\x.\y.IF(x AND NOT y)x y) true false

the boolean values are defined below:

true ≡ λp.λq.p

false ≡ λp.λq.q

AND ≡ λp.λq.p q p

OR ≡ λp.λq.p p q

NOT ≡ λp.p false true

IF ≡ λp.λa.λb.p a b

Any feedback is appreciated.