Consider this: in all decent programming languages you can write functions, e.g. def f(arg) = result Here, f takes a value arg and computes a value result. It is a function from values to values. Now, some languages allow you to define polymorphic (aka generic) values: def empty<T> = new List<T>() Here, empty takes a … Read more
If you already have a b : Bool, you can turn it into proposition: So b, which is a bit shorther than b ≡ true. Sometimes (I don’t remember any actual case) there is no need to bother with a proper data type, and this quick solution is enough. So seems to have serious disadvantages … Read more
Yes, actually you can take some code and convert every function call—and every return—into a tail call. What you end up with is called continuation-passing style, or CPS. For example, here’s a function containing two recursive calls: (define (count-tree t) (if (pair? t) (+ (count-tree (car t)) (count-tree (cdr t))) 1)) And here’s how it … Read more
I’m glad you’re starting by asking about a specification rather than implementation first. There are a lot of ideas floating around about what FRP is. From the very start in the early 90’s (when I was working in interactive graphics at Sun Microsystems and then Microsoft Research), it has been about two properties (a) denotative … Read more
Dart v1.23 added a new syntax for writing function types which also works in-line. void doSomething(Function(int) f) { f(123); } It has the advantage over the function-parameter syntax that you can also use it for variables or anywhere else you want to write a type. void doSomething(Function(int) f) { Function(int) g = f; g(123); } … Read more
Yes and no. Different functional programming languages solve them differently. In Haskell (a very pure one) all this stuff has to happen in something called the I/O Monad – see here. You can think of it as getting another input (and output) into your function (the world-state) or easier as a place where “impureness” like … Read more
As @ljedrz points out, to make it work you only need to reference the composed functions again: let finally = compose(&*multiply_and_add, &*divide_and_subtract); (Note that in Rust, convention dictates that variable names should be in snake_case) However, we can make this better! Since Rust 1.26, we can use abstract return types (previously featured gated as #![feature(conservative_impl_trait)]). … Read more
The word “functor” comes from category theory, which is a very general, very abstract branch of mathematics. It has been borrowed by designers of functional languages in at least two different ways. In the ML family of languages, a functor is a module that takes one or more other modules as a parameter. It’s considered … Read more
Just look at the Wikipedia article to get your definition: Tacit programming (point-free programming) is a programming paradigm in which a function definition does not include information regarding its arguments, using combinators and function composition […] instead of variables. Haskell example: Conventional (you specify the arguments explicitly): sum (x:xs) = x + (sum xs) sum … Read more
I think @Vijay’s answer is the best one so far and I just intend to Erlangify it. Pairs (cons cells) in Erlang are written as [Head|Tail] and nil is written as []. There is no restriction as to what the head and tail are but if you use the tail to chain more cons cells … Read more