390

# tacit programming : Point-free, Concatenatives & J

tacit programming : Point-free, Concatenatives & J ## さっちゃん

December 26, 2019

## Transcript

5. ### tacit programming is a programming method to assembly functions with

no free variables. a.k.a. point-free style

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

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.

is S?

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 K discards y. Ix=x I is identity. SKI is Turing complete.

.

23. ### combinatory logic has no "function application". It has only function

composition & quotation.

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

programming language.
27. ### concatenative programming language Add in Forth. 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?

36. ### J quicksort (the most famous example of J). quicksort=:((\$:@(<#[),(=#[),\$:@(>#[))({[email protected]#))^:(1<#) quicksort

1 _9 2 _8 3 _7 4 _6 5 _9 _8 _7 _6 1 2 3 4 5

numbers.
38. ### Example 1 : add +/2 3 5 2 3 is

a vector. / is fold. So +/ sums the vector.

is tacit.
40. ### Example 2 : average Evaluation flow. (+/ % #) 2

3 (+/ 2 3) % (# 2 3) NB. monadic fork monadic fork : (fgh)x=(fx)g(hx)

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:

` (* [email protected]<:) @. * factorial 9 362880
45. ### Example 3 : factorial Evaluation flow. factorial 2 1: `

(* [email protected]<:) @. * 2 (* [email protected]<:) 2 NB. `@.` selects the second 2 * ([email protected]<: 2) NB. monadic hook monadic hook : (fg)x=xf(gx)
46. ### Example 3 : factorial Evaluation flow. 2 * ([email protected]<: 2)

2 * (factorial 1) 2 * (1 * (factorial 0)) NB. same as `factorial 2` 2 * (1 * (1: ` (* [email protected]<:) @. * 0)) 2 * (1 * (1: 0)) NB. `@.` selects the first 2 * (1 * 1) 2 * 1 2

} - ["mswd"]