さっちゃん
December 26, 2019
600

# tacit programming : Point-free, Concatenatives & J

tacit programming : Point-free, Concatenatives & J

## さっちゃん

December 26, 2019

## Transcript

1. tacit programming
Point-free, Concatenatives & J

2. .｡oO(さっちゃんですよヾ(〃l _ l)ﾉﾞ ☆)

tacit programming

4. tacit?
tacit : silent, unspoken

5. tacit programming
is a programming method to assembly functions with
no free variables.
a.k.a. point-free style

6. point-free style

7. Let's do point-free style
Let's define functions without arguments.

8. Example 1 : factorial
Non-point-free
factorial n = n * factorial (n - 1)
factorial 0 = 1
factorial 9

9. Example 1 : factorial
foldr (*) 1 [1..9]

(foldr (*) 1) . (enumFromTo 1) \$ 9

10. Example 1 : factorial
point-free
factorial = (foldr (*) 1) . (enumFromTo 1)
factorial 9

11. Let's do point-free style
Compose functions.

12. Example 2 : average
Non-point-free
average xs = foldr (+) 0 xs / (fromIntegral . length \$ xs)
average [2, 3]

13. Example 2 : average
point-free
average = ((/) . foldr (+) 0) <*> (fromIntegral . length)
average [2, 3]

14. https://github.com/ghc/ghc/blob/b4fb232892ec420059e767bbf464bd09361aaefa/lib
raries/base/GHC/Base.hs#L973
instance Applicative ((->) a) where
pure = const
(<*>) f g x = f x (g x)
liftA2 q f g x = q (f x) (g x)
(<*>) f g x = f x (g x)
is S.

15. (<*>) f g x = f x (g x)
What is S?

16. point-free style is under
combinatory logic

17. combinatory logic
You know λ-calculus?
λx.1+x
This term has a variable x
.

18. combinatory logic
An raugh image of combinators is, that λx.1+x
becomes + 1 x
.
+ 1
the part of it makes sence.
1 x
also makes sence.

19. One of a form of combinatory logic is
SKI combinator calculus
Sxyz=xz(yz)
S copies z.
Kxy=x
Ix=x
I is identity.
SKI is Turing complete.

20. SKI combinator calculus
I=SKK
because SKKx=Kx(Kx)=x
.
I=SKS
because SKSx=Kx(Sx)=x
.

21. SKI combinator calculus
self-application
SIIx=Ix(Ix)=xx

22. SKI combinator calculus
recrusion
Y=S(K(SII))(S(S(KS)K)(K(SII)))
Yx=xYx

23. combinatory logic
has no "function application".
It has only function composition & quotation.

24. quotaion?

25. concatenative programming
language
is based on combinatory logic

26. concatenative programming language
You know Forth?
Forth is a stack-based programming language.

27. concatenative programming language
2 3 +
1. Put 2 on the stack.
2. Put 3 on the stack.
3. Pop 3 & 2 from the stack, then plus them, put the
result 5 on the stack.

28. concatenative programming language
If 3 +
evaluated lazily it makes sence.
1. Put 3 on the stack.
2. Pop 3 & another value from the stack, then plus
them, put the result ont the stack.
concatenative programming language like
Factor & Popr do this.

29. Example 1 : average
in Popr.
average: dup sum swap length /f
[2 3] averge
concatenatives are always tacit.

30. Example 2 : factorial
in Factor.
: factorial_rec ( n n -- n )
dup 0 = [ drop ] [ [| n m | n m * m 1 - factorial_rec ] call ] if ;
: factorial ( n -- n )
dup 0 < [ drop 0 ] [ 1 swap factorial_rec ] if ;
9 factorial
[ ]
is quotatin. It's evaluated in lazy.

31. Example 2 : factorial
another one in Factor.
MEMO: factorial ( n -- n! )
dup 1 > [ [1,b] product ] [ drop 1 ] if ;
9 factorial

32. Example 2 : factorial
in Popr
factorial: [1 == 1 swap !] [dup dup 1 - factorial * swap 1 > !] | pushl head
9 factorial
1 == 1 swap !
fails when the value is greater
than 1.
dup dup 1 - factorial * swap 1 > !
fails
when the value is 1.

33. concatenative programming language
Unix pipe & filter is tacit.
Concatenatives are extends pipe & filter using stacks.

34. concatenative programming language
is a only way to extends conbinatory logic?
is a only way to extends pipe & filter?

35. J

36. J
quicksort (the most famous example of J).
quicksort=:((\$:@(<#[),(=#[),\$:@(>#[))({~?@#))^:(1<#)
quicksort 1 _9 2 _8 3 _7 4 _6 5
_9 _8 _7 _6 1 2 3 4 5

2+3
5
plus 2 numbers.

+/2 3
5
2 3
is a vector.
/
is fold. So +/
sums the vector.

39. Example 2 : average
average:=(+/%#)
average 2 3
2.5
This is tacit.

40. Example 2 : average
Evaluation flow.
(+/ % #) 2 3
(+/ 2 3) % (# 2 3) NB. monadic fork

41. Example 3 : factorial
!9
362880
:)

42. Example 3 : factorial
*/1+i.9
362880

43. Example 3 : factorial
Evaluation flow. J evaluates a program from right.
*/ 1 + i. 9
*/ 1 + 0 1 2 3 4 5 6 7 8 NB. `i.` creates a vector
*/ 1 2 3 4 5 6 7 8 9 NB. vector operation
1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 NB. fold `*`
362880

44. Example 3 : factorial
another tacit one.
factorial =: 1: ` (* factorial@<:) @. *
factorial 9
362880

45. Example 3 : factorial
Evaluation flow.
factorial 2
1: ` (* factorial@<:) @. * 2
(* factorial@<:) 2 NB. `@.` selects the second
2 * (factorial@<: 2) NB. monadic hook

46. Example 3 : factorial
Evaluation flow.
2 * (factorial@<: 2)
2 * (factorial 1)
2 * (1 * (factorial 0)) NB. same as `factorial 2`
2 * (1 * (1: ` (* factorial@<:) @. * 0))
2 * (1 * (1: 0)) NB. `@.` selects the first
2 * (1 * 1)
2 * 1
2

47. Example 4 : permitation
in Ruby
"mswd".chars.permutation.map { |cs| cs.join("") } - ["mswd"]

48. Example 4 : permitation
in J
str=:'mswd'
((i.!#str)A.str)-.str

49. Example 4 : permitation
tacit J
((([:i.[:!#)A.])-.])'mswd'

50. J
J is a vein of gold.
https://scrapbox.io/ne-sachirou/J