lambdaspeech
::
PLR
1
|
list
|
login
|
load
|
|
_img http://lambdaway.free.fr/workshop/data/canopee.jpg {div {@ style="position:absolute; top:150px; left:-200px; width:340px; font:italic 3.0em georgia; text-align:center; color:#f00; background:#eee; opacity:0.8; padding:10px; box-shadow:0 0 8px #000; border-radius:20px; transform:rotate(-5deg); -webkit-transform:rotate(-5deg); "} Your opinion{br} is welcome{br} in [[agora]]! } _h1 '{lambda zen} _p '{lambda talk} is a small dialect of the λ-calculus language invented in 1936 by the mathematician Alonzo Church, who introduced the concepts of {b expressions} exclusively made of {b words, abstractions & applications}. In this page, using a very minimalistic{sup (*)} notation, I will play with expressions made of {b words, abstractions, applications & definitions} to build {b pairs, lists, trees}, {b numbers} with their related operators and a few other functions illustrating the power - and the limits - of such an approach. _p Everything will be done in a subset of '{lambda talk} reduced to a 100 lines JS evaluator, based on Regular Expressions, explained in detail in [[microtalk]]. In this implementation _ul an {b application} is a nested form {code '{expression expression}} evaluated to words in applicative order, from inside out, _ul an {b abstraction} is a first special form written {code '{lambda {words} expression}} evaluated to a word referencing a function with {code words} as arguments and {code expression} as body, _ul a {b definition} is a second special form written {code '{def word expression}} evaluated to the word {code name} referencing {code expression} in a single dictionary initially empty, _ul special forms are evaluated before nested forms, _ul lambdas are first class functions, accept partial calls and an extendable list of arguments, _ul the evaluation stops when all expressions are reduced to words which are sent to the web browser for any eventual HTML/CSS/SVG/... evaluations and for the final display. _p More can be seen in this [[paper|?view=fabric_new]]. _h3 1. the lambda foundations _p We will build everything on a reduced set of 7 "primitive" functions {pre '{def | {lambda {:a :b} :a}} -> {def | {lambda {:a :b} :a}} // first '{def ø {lambda {:a :b} :b}} -> {def ø {lambda {:a :b} :b}} // rest, nil '{def □ {lambda {:a :b :c} {:c :a :b}}} -> {def □ {lambda {:a :b :c} {:c :a :b}}} // pair '{def [ {lambda {:c} {:c |}}} -> {def [ {lambda {:c} {:c |}}} // left '{def ] {lambda {:c} {:c ø}}} -> {def ] {lambda {:c} {:c ø}}} // right '{def ? {lambda {:c} {:c {| ]} [}}} -> {def ? {lambda {:c} {:c {| ]} [}}} // isnil '{def ¿ {lambda {:c} {:c {| [} ]}}} -> {def ¿ {lambda {:c} {:c {| [} ]}}} // isnotnil } _p {b (*)} Why such a minimalistic notation? At first sight, short names like {code |, ø, □, [, ], ?, ¿} can appear unreadable. In fact they help to write small readable chunks of code. Putting all the stuff in one or two pages instead of ten pages helps to write, read, understand and memorize in one eye shot. At least me! _p What can be done with so little? Let's go! {pre 1) basically the evaluator is a text substitution machine '{{lambda {fruit unknown} // replace "fruit" & "unknown" The color of fruits is unknown!} // in "The color of fruits is unknown!" apple green} // by "apple" & "green" -> {{lambda {fruit unknown} The color of fruits is unknown!} apple green} 2) definitions can be used to create sequences of words accessed with | and ø '{def S a b c d e f g} -> {def S a b c d e f g} // it's a sequence of words '{S} -> {S} '{| {S}} -> {| {S}} // the first word '{ø {S}} -> {ø {S}} // rest of words, lambdas are variadic 3) pairs can be created with □ and accessed with [ and ] '{def P {□ a b}} -> {def P {□ a b}} // a pair, lambdas accept partial calls '{[ {P}} -> {[ {P}} // the left word '{] {P}} -> {] {P}} // the right word 4) ? is a predicate function returning [ for ø and ] for a pair ¿ is a predicate function returning ] for ø and [ for a pair '{? ø} -> {? ø} // is ø empty? yes '{? {P}} -> {? {P}} // is a pair empty? no '{¿ ø} -> {¿ ø} // is ø not empty? no '{¿ {P}} -> {¿ {P}} // is a pair not empty? yes } _h3 2. introducing recursion (could see also [[PLR4]]) _p Pairs can be nested to create recursive structures like {b lists} and {b trees}. Their elements will be naturally accessed via {b recursion}. Recursion just needs pairs to bind two terms and lambdas to {b delay} evaluation which is by default in {b applicative order}, from inside out. _h4 2.1. on lists _p Lists are a first type of nested pairs ending with ø. {pre '{def L {□ a {□ b {□ c {□ d {□ e {□ f {□ g ø}}}}}}}} -> {def L {□ a {□ b {□ c {□ d {□ e {□ f {□ g ø}}}}}}}} '{[ {L}} -> {[ {L}} '{[ {] {L}}} -> {[ {] {L}}} '{[ {] {] {L}}}} -> {[ {] {] {L}}}} ... '{[ {] {] {] {] {] {] {L}}}}}}}} -> {[ {] {] {] {] {] {] {L}}}}}}}} '{] {] {] {] {] {] {] {L}}}}}}}} -> {] {] {] {] {] {] {] {L}}}}}}}} } _p This sequence of accesses enlights a recursive process {pre '{def D // list.display {lambda {:l} {{{? :l} {□ {lambda {:l} } {lambda {:l} {[ :l} {D {] :l}} } }} :l}}} -> {def D {lambda {:l} {{{? :l} {□ {lambda {:l} } {lambda {:l} {[ :l} {D {] :l}} } }} :l}}} '{D {L}} -> {D {L}} } _p Lists can be reversed and appended {pre '{def R // list.reverse {def R.r {lambda {:a :b} {{{? :a} {□ {lambda {:a :b} :b} {lambda {:a :b} {R.r {] :a} {□ {[ :a} :b}}} }} :a :b}}} {lambda {:a} {R.r :a ø}}} -> {def R {def R.r {lambda {:a :b} {{{? :a} {□ {lambda {:a :b} :b} {lambda {:a :b} {R.r {] :a} {□ {[ :a} :b}}} }} :a :b}}} {lambda {:a} {R.r :a ø}}} '{def A // list.append {def A.r {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {A.r {□ {[ :b} :a} {] :b}}} }} :a :b}}} {lambda {:a :b} {A.r :a {R :b}}}} -> {def A {def A.r {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {A.r {□ {[ :b} :a} {] :b}}} }} :a :b}}} {lambda {:a :b} {A.r :a {R :b}}}} '{D {R {L}}} -> {D {R {L}}} '{D {A {L} {R {L}}}} -> {D {A {L} {R {L}}}} } _h4 2.2. on trees _p Trees are another type of nested pairs ending with ø. {pre '{def T {□ {□ {□ {□ A ø} {□ B ø}} {□ {□ C ø} {□ D ø}} } {□ {□ {□ E ø} {□ F ø}} {□ {□ G ø} {□ H ø}} }}} -> {def T {□ {□ {□ {□ A ø} {□ B ø}} {□ {□ C ø} {□ D ø}} } {□ {□ {□ E ø} {□ F ø}} {□ {□ G ø} {□ H ø}} } }} '{def W // tree.display {lambda {:p} {{{? {] :p}} {□ {lambda {:p} {[ :p}} {lambda {:p} ({W {[ :p}} {W {] :p}})}}} :p}}} -> {def W {lambda {:p} {{{? {] :p}} {□ {lambda {:p} {[ :p}} {lambda {:p} ({W {[ :p}} {W {] :p}})}}} :p}}} '{W {T}} -> {W {T}} } _p More to do with trees later. _p Before going further I would like to introduce a strange operator, the {b Y-combinator}. If you are not curious about the Y-combinator skip the next section and move on to {b 3. arithmetic}. {blockquote {@ style="background:#eee; padding:5px;"} _img http://www.artkadit.fr/medias/images/image-2.jpg {center {i Le baron perché - Italo Calvino}} _p In '{lambda talk} the Y-combinator is a very small and simple function waiting for a function and a word and applying this function to itself and to the word. {center {b {pre '{def Y {lambda {:f :n} {:f :f :n}}} -> {def Y {lambda {:f :n} {:f :f :n}}} }}} _p Sounds recursive, isnt'it? The Y-combinator transforms {b almost recursive} functions into {b recursive} functions. Let's rewrite our first recursive function, the display function {code D} {pre '{def D {lambda {:l} {{{? :l} {□ {lambda {:l} } {lambda {:l} {[ :l} {D {] :l}} } }} :l}}} '{D {L}} -> {D {L}} } _p as an almost-recursive function {code DD}, a function which doesn't call itself {pre '{def DD {lambda {:f :l} {{{? :l} {□ {lambda {:f :l} } {lambda {:f :l} {[ :l} {:f :f {] :l}} } }} :f :l}}} -> {def DD {lambda {:f :l} {{{? :l} {□ {lambda {:f :l} } {lambda {:f :l} {[ :l} {:f :f {] :l}} } }} :f :l}}} '{Y DD {L}} -> {Y DD {L}} } _p Note the "slot" {code :f} added to the argument {code :l} which is used by the Y-combinator to create the recursive process. Let's compose the both {pre '{def YD {lambda {:l} {{lambda {:f :l} {:f :f :l}} {lambda {:f :l} {{{? :l} {□ {lambda {:f :l} } {lambda {:f :l} {[ :l} {:f :f {] :l}} } }} :f :l}} :l}}} -> {def YD {lambda {:l} {{lambda {:f :l} {:f :f :l}} {lambda {:f :l} {{{? :l} {□ {lambda {:f :l} } {lambda {:f :l} {[ :l} {:f :f {] :l}} } }} :f :l}} :l}}} '{YD {L}} -> {YD {L}} } _p Because the name {code YD} doesn't appear anymore in the function's body we can forget it and write an IIFE (Immediately Invoked Function Expression), an anonymous function applied to the list {code L} {pre '{{lambda {:l} {{lambda {:f :l} {:f :f :l}} {lambda {:f :l} {{{? :l} {□ {lambda {:f :l} } {lambda {:f :l} {[ :l} {:f :f {] :l}} } }} :f :l}} :l}} {L}} -> {{lambda {:l} {{lambda {:f :l} {:f :f :l}} {lambda {:f :l} {{{? :l} {□ {lambda {:f :l} } {lambda {:f :l} {[ :l} {:f :f {] :l}} } }} :f :l}} :l}} {L}} } _p We can now replace all the names [{code |, ø, □, [, ], ?, L}] by their lambda expressions to build a pure λ-calculus expression made of words and lambdas {prewrap '{{lambda {:l} {{lambda {:f :l} {:f :f :l}} {lambda {:f :l} {{{{lambda {:c} {:c {{lambda {:a :b} :a} {lambda {:c} {:c {lambda {:a :b} :b}}}} {lambda {:c} {:c {lambda {:a :b} :a}}}}} :l} {{lambda {:a :b :c} {:c :a :b}} {lambda {:f :l} } {lambda {:f :l} {{lambda {:c} {:c {lambda {:a :b} :a}}} :l} {:f :f {{lambda {:c} {:c {lambda {:a :b} :b}}} :l}} } }} :f :l}} :l}} {{lambda {:a :b :c} {:c :a :b}} a {{lambda {:a :b :c} {:c :a :b}} b {{lambda {:a :b :c} {:c :a :b}} c {{lambda {:a :b :c} {:c :a :b}} d {{lambda {:a :b :c} {:c :a :b}} e {{lambda {:a :b :c} {:c :a :b}} f {{lambda {:a :b :c} {:c :a :b}} g {lambda {:a :b} :b}}}}}}}}} -> {{lambda {:l} {{lambda {:f :l} {:f :f :l}} {lambda {:f :l} {{{{lambda {:c} {:c {{lambda {:a :b} :a} {lambda {:c} {:c {lambda {:a :b} :b}}}} {lambda {:c} {:c {lambda {:a :b} :a}}}}} :l} {{lambda {:a :b :c} {:c :a :b}} {lambda {:f :l} } {lambda {:f :l} {{lambda {:c} {:c {lambda {:a :b} :a}}} :l} {:f :f {{lambda {:c} {:c {lambda {:a :b} :b}}} :l}} } }} :f :l}} :l}} {{lambda {:a :b :c} {:c :a :b}} a {{lambda {:a :b :c} {:c :a :b}} b {{lambda {:a :b :c} {:c :a :b}} c {{lambda {:a :b :c} {:c :a :b}} d {{lambda {:a :b :c} {:c :a :b}} e {{lambda {:a :b :c} {:c :a :b}} f {{lambda {:a :b :c} {:c :a :b}} g {lambda {:a :b} :b}}}}}}}}} } _p Long life to this good old {b λ-calculus{sup (1936)}}! } _h3 3. introducing arithmetic _p We know how to display lists' items. But instead of displaying lists' items we could display dots {pre '{def K // list.length {lambda {:l} {{{? :l} {□ {lambda {:l} } {lambda {:l} . {K {] :l}} } }} :l}}} -> {def K {lambda {:l} {{{? :l} {□ {lambda {:l} } {lambda {:l} . {K {] :l}} } }} :l}}} '{K {L}} -> {K {L}} // read 7 items } _p It's a kind of primitive unary numeration which can be replaced by a more modern one, if we accept, only for display, to use the numbers of Javascript, the underlying language. {pre '{def N // number.display {lambda {:l} {{{? :l} {□ {lambda {:l} 0} {lambda {:l} {+ 1 {N {] :l}}} } }} :l}}} -> {def N {lambda {:l} {{{? :l} {□ {lambda {:l} 0} {lambda {:l} {+ 1 {N {] :l}}} } }} :l}}} '{N {L}} -> {N {L}} } _p It's a matter of choice. In what follows I will use the {b N} display mode. _h4 3.1. foundations _p We will simply define {b natural numbers} as lists of dots. {b zero} will be {b ø}, {b one} will be {b '{□ . ø}}, {b two} will be {b '{□ . {□ . ø}}} and so on. Two operators {b « & »} will help to build the sequence of numbers and to get a number before or after any number. {pre '{def » {lambda {:n} {□ . :n}}} // next -> {def » {lambda {:n} {□ . :n}}} '{def « {lambda {:n} {{{? :n} {□ ø {] :n}}}}}} // prev -> {def « {lambda {:n} {{{? :n} {□ ø {] :n}}}}}} '{def zero ø} = '{N {zero}} -> {def zero ø} = {N {zero}} '{def one {» {zero}}} = '{N {one}} -> {def one {» {zero}}} = {N {one}} '{def two {» {one}}} = '{N {two}} -> {def two {» {one}}} = {N {two}} '{def three {» {two}}} = '{N {three}} -> {def three {» {two}}} = {N {three}} '{def four {» {three}}} = '{N {four}} -> {def four {» {three}}} = {N {four}} '{def five {» {four}}} = '{N {five}} -> {def five {» {four}}} = {N {five}} ... and so on } _h4 3.2. operators {pre '{def ++ // add {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {++ {» :a} {« :b}}} }} :a :b}}} -> {def ++ {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {++ {» :a} {« :b}}} }} :a :b}}} '{def -- // sub {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {-- {« :a} {« :b}}} }} :a :b}}} -> {def -- {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {-- {« :a} {« :b}}} }} :a :b}}} '{def ** // times {def **.r {lambda {:a :b :c} {{{? :b} {□ {lambda {:a :b :c} :a} {lambda {:a :b :c} {**.r {++ :a :c} {« :b} :c}} }} :a :b :c}}} {lambda {:a :b} {**.r :a {« :b} :a}}} -> {def ** {def **.r {lambda {:a :b :c} {{{? :b} {□ {lambda {:a :b :c} :a} {lambda {:a :b :c} {**.r {++ :a :c} {« :b} :c}} }} :a :b :c}}} {lambda {:a :b} {**.r :a {« :b} :a}}} '{def *** // power {def ***.r {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {***.r {++ :a :a} {« :b}}} }} :a :b}}} {lambda {:a :b} {***.r :a {« :b}}}} -> {def *** {def ***.r {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {***.r {++ :a :a} {« :b}}} }} :a :b}}} {lambda {:a :b} {***.r :a {« :b}}}} '{def // // divide {lambda {:x :y} {{{? {-- :y :x}} {□ {lambda {:x :y} {++ {one} {// {-- :x :y} :y}}} {lambda {:x :y} {zero}} }} :x :y}}} -> {def // {lambda {:x :y} {{{? {-- :y :x}} {□ {lambda {:x :y} {++ {one} {// {-- :x :y} :y}}} {lambda {:x :y} {zero}} }} :x :y}}} '{def %% // modulo {lambda {:x :y} {-- :x {** {// :x :y} :y}}}} -> {def %% {lambda {:x :y} {-- :x {** {// :x :y} :y}}}} '{def !! {lambda {:a :b} // factorial {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {!! {** :a :b} {« :b}}} }} :a :b}}} -> {def !! {lambda {:a :b} {{{? :b} {□ {lambda {:a :b} :a} {lambda {:a :b} {!! {** :a :b} {« :b}}} }} :a :b}}} } _p testing {prewrap '{N {« {two}}} -> {N {« {two}}} '{N {« {one}}} -> {N {« {one}}} '{N {« {zero}}} -> {N {« {zero}}} // zero is the floor of natural numbers '{N {++ {four} {three}}} -> {N {++ {four} {three}}} '{N {** {four} {three}}} -> {N {** {four} {three}}} '{N {-- {four} {three}}} -> {N {-- {four} {three}}} '{N {// {four} {three}}} -> {N {// {four} {three}}} '{N {// {four} {two}}} -> {N {// {four} {two}}} '{N {// {four} {one}}} -> {N {// {four} {one}}} '{N {%% {four} {three}}} -> {N {%% {four} {three}}} '{N {%% {four} {two}}} -> {N {%% {four} {two}}} '{N {*** {two} {five}}} -> {N {*** {two} {five}}} '{N {!! {one} {five}}} -> 120 ;; too much for an old first generation iPad :( } _p And so on. _p {b Note:} It's obvious that defining numbers as lists of dots is very, very inefficient if we have to do useful arithmetic. A decimal position numeration would be a much better choice and it's the next work to do, (see [[numbers]]). Meanwhile small numbers will help us to play with some interesting applications. _h3 4. some applications _p Let's present three applications. _h5 4.1. SERIE & MAP _p The {code SERIE} function displays a list of ascending numbers and the {code MAP} function applies a function on such a list, a kind of iterative structure. {pre '{def MAP {def MAP.r {lambda {:f :l :acc} {{{? :l} {□ {lambda {:f :l :acc} :acc} {lambda {:f :l :acc} {MAP.r :f {] :l} {□ {:f {[ :l}} :acc}}} }} :f :l :acc}}} {lambda {:f :l} {MAP.r :f :l ø}}} -> {def MAP {def MAP.r {lambda {:f :l :acc} {{{? :l} {□ {lambda {:f :l :acc} :acc} {lambda {:f :l :acc} {MAP.r :f {] :l} {□ {:f {[ :l}} :acc}}} }} :f :l :acc}}} {lambda {:f :l} {MAP.r :f :l ø}}} '{def SERIE {def SERIE.r {lambda {:a :b :l} {{{? {-- :b :a}} {□ {lambda {:a :b :l} {□ :b :l}} {lambda {:a :b :l} {SERIE.r {» :a} :b {□ :a :l}}} }} :a :b :l}}} {lambda {:a} {SERIE.r {one} :a ø}}} -> {def SERIE {def SERIE.r {lambda {:a :b :l} {{{? {-- :b :a}} {□ {lambda {:a :b :l} {□ :b :l}} {lambda {:a :b :l} {SERIE.r {» :a} :b {□ :a :l}}} }} :a :b :l}}} {lambda {:a} {SERIE.r {one} :a ø}}} '{D {MAP N {SERIE {five}}}} -> {D {MAP N {SERIE {five}}}} '{D {MAP {lambda {:n} {N {*** {two} :n}}} {SERIE {five}}}} -> {D {MAP {lambda {:n} {N {*** {two} :n}}} {SERIE {five}}}} } _h5 4.2. The Towers of Hanoï _p The game {b Towers of Hanoï} gives an example of double recursion {pre '{def hanoi {lambda {:n :from :to :via} {{{? :n} {□ {lambda {:n :from :to :via} } {lambda {:n :from :to :via} {hanoi {« :n} :from :via :to} {br} move disc {N :n} from tower :from to tower :to {hanoi {« :n} :via :to :from} }}} :n :from :to :via}}} -> {def hanoi {lambda {:n :from :to :via} {{{? :n} {□ {lambda {:n :from :to :via} } {lambda {:n :from :to :via} {hanoi {« :n} :from :via :to} {br} move disc {N :n} from tower :from to tower :to {hanoi {« :n} :via :to :from} }}} :n :from :to :via}}} '{hanoi {four} A B C} -> } {pre {hanoi {four} A B C} } _h5 4.3. The Hilbert Curve _p The Hilbert curve is built on two twinned functions {code left & right} {pre '{def left {lambda {:d :n} {{{? :n} {□ {lambda {:d :n} } {lambda {:d :n} T90 {right :d {« :n}} M:d T-90 {left :d {« :n}} M:d {left :d {« :n}} T-90 M:d {right :d {« :n}} T90 }}} :d :n}}} -> {def left {lambda {:d :n} {{{? :n} {□ {lambda {:d :n} } {lambda {:d :n} T90 {right :d {« :n}} M:d T-90 {left :d {« :n}} M:d {left :d {« :n}} T-90 M:d {right :d {« :n}} T90 }}} :d :n}}} '{def right {lambda {:d :n} {{{? :n} {□ {lambda {:d :n} } {lambda {:d :n} T-90 {left :d {« :n}} M:d T90 {right :d {« :n}} M:d {right :d {« :n}} T90 M:d {left :d {« :n}} T-90 }}} :d :n}}} -> {def right {lambda {:d :n} {{{? :n} {□ {lambda {:d :n} } {lambda {:d :n} T-90 {left :d {« :n}} M:d T90 {right :d {« :n}} M:d {right :d {« :n}} T90 M:d {left :d {« :n}} T-90 }}} :d :n}}} } _p we write {pre '{left 10 {one}} '{left 10 {two}} '{left 10 {three}} } _p to generate these sequences of drawing commands {prewrap {left 10 {one}} {left 10 {two}} {left 10 {three}} ... } _p which can be used by a [[turtle graphic|/?view=hilbert]] tool to display _img http://www.datagenetics.com/blog/march22013/c.png _p More can be seen in this [[paper|http://lambdaway.free.fr/lambdaspeech/?view=fabric_new]]. _h3 conclusion _p To sum up, with three rules [{code abstraction, application, definition}] working on words, we could define data structures and data controls, on which can be built every objects we want, at least theoretically. In the real life defining numbers as lists of dots has severe limits, the evaluation is very slow and quickly exhausts the capabilities of the computer. Obviously calling numbers defined as primitives of the underlying language will be the way. And it's what '{lambda talk} does to begin to be a true functional language. But it's another story. _p Meanwhile we could stay for a short time at the foundation level of a computing language and play with its essential concepts. Be aware (see [[paper|?view=fabric_new]]) that the '{lambda talk}'s engine is not built on a standard parser, translating the code string into a syntaxic tree before evaluating it, but is a Regular Expression window running on the code, replacing {i in situ} expressions by words until the code contains nothing but words. For instance such an expression {code '{sqrt {+ {* 3 3} {* 4 4}}}} is first evaluated to {code '{sqrt {+ 9 16}}} then to {code '{sqrt 25}} and finally to {b 5}. It's the {b application} side of the language. The following expression {code '{sqrt {+ {* x x} {* y y}}}} can't be evaluated because {code x y} have no numerical value. Here come lambdas. Writing {code '{lambda {x y} {sqrt {+ {* x x} {* y y}}}}} {b delays} its evaluation until {code x y} will be given a value. It's the {b abstraction} side of the language. _p {b abstraction & application} are the {b Yin & Yang} of a language. The λ-calculus is not this horrible thing quickly introduced in CSS courses before dealing with true usable languages. '{λ-calculus} is for the human mind what assembly language is for the computer and can help to stay in the {b ZEN} attitude! Amazing, isnt'it? _p More can be seen in {u [[lambdaspeech|?view=start]]}. Your opinion is welcome, for instance in [[agora]] or in [[reddit|https://www.reddit.com/r/lisp/comments/9u1rlv/lambda_zen/]], why not? _p {i alain marty 2018/11/04-11} _img http://epsilonwiki.free.fr/ELS_YAW/data/2CV_boule_et_bill.jpg {center {i The pleasure of simple things.}} _p See also [[https://www.reddit.com/r/lambdacalculus/|https://www.reddit.com/r/lambdacalculus/comments/9zyx44/plam_a_pure_%CE%BBcalculus_interpreter/]] {style ;; @import url(https://fonts.googleapis.com/css?family=Quicksand); #page_content { font-family: Quicksand; font-size:1.0em; background:#eee; } }
lambdaspeech v.20200126