Tacit programming: Difference between revisions

Tacit programming (view source)

Revision as of 09:31, 30 June 2022

9,758 bytes added , 09:31, 30 June 2022

→‎Summary of rules: moved to Function composition

Adám Brudzewsky

Bureaucrats, Interface administrators, Administrators, trusted

4,493

edits

@@ Line 1: / Line 1: @@
-Tacit functions apply to implicit arguments following a small set of rules. This is in contrast to the explicit use of arguments in [[dfns]] (<source inline lang=apl>⍺ ⍵</source>) and [[tradfns]] (which have named arguments). Known dialects which implement trains are [[Dyalog APL]], [[dzaima/APL]], [[ngn/apl]] and [[NARS2000]].
+'''Tacit programming''', also called '''[[wikipedia:Tacit_programming|point-free style]]''', refers to usage of tacit [[function]]s that are defined in terms of implicit [[argument]]s. This is in contrast to the explicit use of arguments in [[dfn]]s (<source inline lang=apl>⍺ ⍵</source>) and [[tradfn]]s (which have named arguments). Some APL dialects allow to combine functions into [[#trains|trains]] following a small set of rules. This allows creating complex [[derived function]]s without specifying any arguments explicitly.
+Dialects which implement trains include [[Dyalog APL]], [[dzaima/APL]], [[ngn/apl]] and [[NARS2000]].
 == Primitives ==
@@ Line 32: / Line 34: @@
 == Trains ==
-A train is a series of functions in isolation. An isolated function is either surrounded by parentheses or named. Arguments are processed by the following rules:
+A train is a series of functions in isolation. An isolated function is either surrounded by parentheses or named. Below, <source lang=apl inline>⍺</source> and <source lang=apl inline>⍵</source> refer to the arguments of the train. <source lang=apl inline>f</source>, <source lang=apl inline>g</source>, and <source lang=apl inline>h</source> are functions (which themselves can be tacit or not), and <source lang=apl inline>A</source> is an array. The arguments are processed by the following rules:
+=== 3-trains ===
+A 3-train is a ''fork'', so denoted because its structure resembles a three-tines fork, or a three-pronged pitchfork. The two outer functions are applied first, and their results are used as arguments to the middle function:
+{|
+|<source lang=apl>  (f g h) ⍵</source>|| {{←→}} ||<source lang=apl>(  f ⍵) g (  h ⍵)</source>
+|-
+|<source lang=apl>⍺ (f g h) ⍵</source>|| {{←→}} ||<source lang=apl>(⍺ f ⍵) g (⍺ h ⍵)</source>
+|}
+The ''left tine'' of a fork can be an array:
+{|
+|<source lang=apl>  (A g h) ⍵</source>|| {{←→}} ||<source lang=apl>A g (  h ⍵)</source>
+|-
+|<source lang=apl>⍺ (A g h) ⍵</source>|| {{←→}} ||<source lang=apl>A g (⍺ h ⍵)</source>
+|}
+=== 2-trains ===
+Most dialects define a 2-train is an ''atop'', equivalent to the function derived using the [[Atop (operator)|Atop]] operator. The left function is applied [[monadic function|monadically]] on the result of the right function:
+{|
+|<source lang=apl>  (g h) ⍵</source>|| {{←→}} ||<source lang=apl>g (  h ⍵)</source>
+|-
+|<source lang=apl>⍺ (g h) ⍵</source>|| {{←→}} ||<source lang=apl>g (⍺ h ⍵)</source>
+|}
+Only [[dzaima/APL]] allows <source lang=apl inline>(A h)</source>, which it treats as <source lang=apl inline>A∘h</source>.<ref>dzaima/APL: [https://github.com/dzaima/APL/blob/ceea05e25687988ed0980a4abf4b9249b736543f/docs/differences.txt#L19 Differences from Dyalog APL]. Retrieved 09 Jan 2020.</ref> See [[Bind]].
+[[J]] instead defines the 2-train as a [[hook]], equivalent to the function derived using the [[Withe]] operator. The left function is always applied [[dyadic function|dyadically]], taking as right argument, the result of applying the right function on the right argument. If there is no left argument, the sole argument is used also as left argument:
+{|
+|<source lang=apl>  (g h) ⍵</source>|| {{←→}} ||<source lang=apl>⍵ g (h ⍵)</source>
+|-
+|<source lang=apl>⍺ (g h) ⍵</source>|| {{←→}} ||<source lang=apl>⍺ g (h ⍵)</source>
+|}
+=== Problems caused by function-operator overloading ===
+Trains that use a [[Function-operator_overloading|hybrid function-operator]] in its [[function]] role can run into the problems with the hybrid being parsed as a monadic [[operator]] instead of as a function. This happens when a function appears to the immediate left of the hybrid, causing this function to be bound as the hybrid's operand — the hybrid taking on an operator role — rather than supplying a left [[argument]] or post-processing the result.
-A 2-train is an ''atop'':
+For example, the attempted [[#3-trains|fork]] <source lang=apl inline>f/h</source> is actually parsed as the [[#2-trains|atop]] <source lang=apl inline>(f/)h</source> and the attempted atop <source lang=apl inline>f/</source> is actually parsed as a [[Windowed Reduce|Windowed Reduction]]. There are multiple [[Function-operator_overloading#Mitigation|ways to mitigate this issue]]. For example, the fork can be enforced using the [[Atop (operator)|Atop operator]] by applying identity to the hybrid's result as <source lang=apl inline>f⊢⍤/h</source> and the atop can be enforced by using the explicit Atop operator instead of a 2-train; <source lang=apl inline>f⍤/</source>.
+No problem presents when left argument is supplied as an array (literal or by name reference) and when the hybrid is the leftmost token. For example, <source lang=apl inline>1 0 1/⌽</source> and <source lang=apl inline>/,⊃</source> are parsed as forks.
+== Debugging ==
+In [[Dyalog APL]], analysis of trains is assisted by a [[user command]] <source lang=apl inline>]Boxing on</source>. This is achieved by executing the command <source lang=apl inline>]Boxing on</source> and then entering a train without any parameters. A structure of the train will be displayed.
+For example, the "accursed train" from the section below can be analysed like this:
 <source lang=apl>
-  (g h) ⍵ ⬄ g (  h ⍵)
+      ]Boxing on
-⍺ (g h) ⍵ ⬄ g (⍺ h ⍵)
+Was OFF
+      ((+.×⍨⊢~∘.×⍨)1↓⍳)     ⍝ the train to be analysed
+┌───────────────────────────────┬───────┐
+│┌───────────┬─────────────────┐│┌─┬─┬─┐│
+││┌───────┬─┐│┌─┬─┬───────────┐│││1│↓│⍳││
+│││┌─┬─┬─┐│⍨│││⊢│~│┌───────┬─┐│││└─┴─┴─┘│
+││││+│.│×││ │││ │ ││┌─┬─┬─┐│⍨││││       │
+│││└─┴─┴─┘│ │││ │ │││∘│.│×││ ││││       │
+││└───────┴─┘││ │ ││└─┴─┴─┘│ ││││       │
+││           ││ │ │└───────┴─┘│││       │
+││           │└─┴─┴───────────┘││       │
+│└───────────┴─────────────────┘│       │
+└───────────────────────────────┴───────┘
 </source>
-A 3-train is a ''fork'':
+Alternatively, a train can be represented in form of a tree:
 <source lang=apl>
-  (f g h) ⍵ ⬄ (  f ⍵) g (  h ⍵)
+      ]Boxing on -trains=tree
-⍺ (f g h) ⍵ ⬄ (⍺ f ⍵) g (⍺ h ⍵)
+Was ON -trains=box
+      ((+.×⍨⊢~∘.×⍨)1↓⍳)     ⍝ the train to be analysed
+     ┌───┴───┐
+   ┌─┴─┐   ┌─┼─┐
+   ⍨ ┌─┼─┐ 1 ↓ ⍳
+  ┌─┘ ⊢ ~ ⍨
+  .     ┌─┘
+┌┴┐    .
++ ×   ┌┴┐
+      ∘ ×
 </source>
+Or fully parenthesised:
-The ''left tine'' of a fork can be an array:
 <source lang=apl>
-  (A g h) ⍵ ⬄ A g (  h ⍵)
+      ]Boxing on -trains=parens
-⍺ (A g h) ⍵ ⬄ A g (⍺ h ⍵)
+Was OFF -trains=box
+      ((+.×⍨⊢~∘.×⍨)1↓⍳)     ⍝ the train to be analysed
+(((+.×)⍨)(⊢~((∘.×)⍨)))(1↓⍳)
 </source>
-Only [[dzaima/APL]] allows <source lang=apl inline>(A h)</source>, which it treats as <source lang=apl inline>A∘h</source>.<ref>dzaima/APL: [https://github.com/dzaima/APL/blob/ceea05e25687988ed0980a4abf4b9249b736543f/docs/differences.txt#L19 Differences from Dyalog APL]. Retrieved 09 Jan 2020.</ref>
 == Examples ==
-One of the major benefits of tacit programming is the ability to convey a short, well-defined idea as an isolated expression. This aids both human readability ([[semantic density]]) and the computer's ability to interpret code, potentially executing special code for particular [[idioms]].
+One of the major benefits of tacit programming is the ability to convey a short, well-defined idea as an isolated expression. This aids both human readability ([[semantic density]]) and the computer's ability to interpret code, potentially executing special code for particular [[idiom]]s.
 === Plus and minus ===
 <source lang=apl>
-       (+,-)2
+       (+,-) 2     ⍝ ±2
 ¯2
-2 3 (+,-) 4
+(+,-) 2   ⍝ 5±2
-6 7 ¯3 ¯2 ¯1
+3
-      (2 3⍴0) (+,-) 1
-1 1 ¯1 ¯1 ¯1
-1 1 ¯1 ¯1 ¯1
 </source>
@@ Line 76: / Line 137: @@
 === Fractions ===
-We can convert decimal numbers to fractions. For example, we can convert <math>2.625</math> to the improper fraction <math>21\over 8</math> with
+We can convert decimal numbers to fractions. For example, we can convert <math>2.625</math> to the improper fraction <math>\tfrac{21}{8}</math> with
 <source lang=apl>
        (1∧⊢,÷)2.625
 8
 </source>
-Alternatively, we can convert it to the mixed fraction <math>2{5\over 8}</math> with
+Alternatively, we can convert it to the mixed fraction <math>2\tfrac{5}{8}</math> with a mixed fraction:
-A mixed fraction:
 <source lang=apl>
        (1∧0 1∘⊤,÷)2.625
@@ Line 119: / Line 179: @@
 0 2
 </source>
 For a more parallel comparison of the notations, see the [[Comparison_with_traditional_mathematics#Practical_example|comparison with traditional mathematics]].
-==References==
+===The Number of the Beast===
+The following expression for computing the [[wikipedia:666 (number)|number of the Beast]] (and of [[I.P. Sharp]]'s APL-based email system, [[666 BOX]]) nicely illustrates how to read a train.
+<source lang=apl>
+      ((+.×⍨⊢~∘.×⍨)1↓⍳)17 ⍝ Accursed train
+</source>
+First, <source lang=apl inline>((+.×⍨⊢~∘.×)1↓⍳)</source> is supplied with only one argument <source lang=apl inline>17</source> and is thus interpreted monadically.
+Second, <source lang=apl inline>(+.×⍨⊢~∘.×⍨)1↓⍳</source> is a 4-train: reading right-to-left, the last 3 components are interpreted as the fork <source lang=apl inline>1↓⍳</source> and the 4-train is interpreted as the atop <source lang=apl inline>(+.×⍨⊢~∘.×⍨)(1↓⍳)</source>.
+Similarly, <source lang=apl inline>(+.×⍨⊢~∘.×⍨)</source> is also a 4-train and interpreted as the atop <source lang=apl inline>+.×⍨(⊢~∘.×⍨)</source>.
+Thus the accursed train is interpreted as <source lang=apl inline>((+.×⍨(⊢~∘.×⍨))(1↓⍳))17</source>. Having read the train, we now evaluate it monadically.
+<source lang=apl>
+      ((+.×⍨(⊢~∘.×⍨))(1↓⍳))17 ⍝ Accursed train as an atop over a fork atop a fork
+      +.×⍨(⊢~∘.×⍨)1↓⍳17       ⍝ Atop evalution
+      +.×⍨(⊢1↓⍳17)~∘.×⍨1↓⍳17  ⍝ Fork evalution
+      +.×⍨(1↓⍳17)~∘.×⍨1↓⍳17   ⍝ ⊢ evaluation
+      +.×⍨2 3 5 7 11 13 17    ⍝ numbers 2 through 17 without those appearing in their multiplication table are primes
+                           ⍝ the sum of the squares of the primes up to 17
+</source>
+Note that <source lang=apl inline>((⊢⍨∘.×⍨)1↓⍳)</source> is a train computing primes up to the given input.
+A more satisfying variation of the accursed train is the following.
+<source lang=apl>
+      (⍎⊢,⍕∘≢)'((+.×⍨⊢~∘.×⍨)1↓⍳)'                    ⍝ Accursed train 2.0
+      ⍎(⊢,⍕∘≢)'((+.×⍨⊢~∘.×⍨)1↓⍳)'                    ⍝ 4-train intepreted as an atop
+      ⍎(⊢'((+.×⍨⊢~∘.×⍨)1↓⍳)'),⍕∘≢'((+.×⍨⊢~∘.×⍨)1↓⍳)' ⍝ fork evaluation
+      ⍎'((+.×⍨⊢~∘.×⍨)1↓⍳)','17'                      ⍝ ⊢ evaluation and ⍕∘≢ evaluation
+      ⍎'((+.×⍨⊢~∘.×⍨)1↓⍳)17'                         ⍝ , evaluation
+                                                  ⍝ ⍎ executes original Accursed train
+</source>
+== See also ==
+* [[Function composition]]
+== External links ==
+=== Tutorials ===
+<div style="column-width:30em">
+==== In text form ====
+* [[Learning APL]]: [https://xpqz.github.io/learnapl/tacit.html Trainspotting]
+* [[Documentation_suites#Dyalog_APL|Dyalog documentation]]: [https://help.dyalog.com/16.0/Content/RelNotes14.0/Function%20Trains.htm version 14.0 release notes]
+* [[Dfns workspace]]: [https://dfns.dyalog.com/n_tacit.htm Translation of <nowiki>[dfns]</nowiki> into tacit form]
+* [[APL Cultivation]]: [https://chat.stackexchange.com/rooms/52405/conversation/lesson-23-transcribing-to-and-reading-trains Transcribing to and reading trains]
+* gitonthescene: [https://gist.github.com/gitonthescene/666c77ee3ed0ae0a79cf8e057584b7fd Forks: Spoon fed]
+* gitonthescene: [https://gist.github.com/gitonthescene/5e9c25ab9edd2f2ce0d5ad38d8a8b2b4 Training day]
+==== Videos ====
+* [[APLtrainer]]: [https://www.youtube.com/watch?v=kt4lMZbn-so How to read trains in Dyalog APL code]
+* [[APLtrainer]]: [https://www.youtube.com/watch?v=A2LqqBosvY0 Function trains in APL]
+* [[Dyalog webinar]]: [https://www.youtube.com/watch?v=Enlh5qwwDuY?t=440 Train Spotting in Dyalog APL]
+* [[Dyalog '13]]: [https://www.youtube.com/watch?v=7-93GzDqC08 Train Spotting in Version 14.0]
+</div>
+=== Documentation ===
+* [https://help.dyalog.com/16.0/Content/RelNotes14.0/Function%20Trains.htm Announcement]
+* [https://help.dyalog.com/latest/Content/Language/Introduction/Trains.htm Dyalog]
+== References ==
 <references/>
-{{APL syntax}}
+{{APL syntax}}[[Category:Tacit programming| ]]

Tacit programming: Difference between revisions

Tacit programming (view source)

Revision as of 09:31, 30 June 2022

Navigation menu

Search