Upgrade to Pro — share decks privately, control downloads, hide ads and more …

tacit programming : Point-free, Concatenatives & J

tacit programming : Point-free, Concatenatives & J

tacit programming : Point-free, Concatenatives & J

4b071f90c5d9c0a58e2d9076460b7be4?s=128

さっちゃん

December 26, 2019
Tweet

Transcript

  1. tacit programming Point-free, Concatenatives & J

  2. .。oO(さっちゃんですよヾ(〃l _ l)ノ゙ ☆)

  3. I'll talking about 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 in Haskell

  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. Don't think about values.

  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 K discards y. 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 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?
  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
  37. Example 1 : add 2+3 5 dyadic + plus 2

    numbers.
  38. Example 1 : add +/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 monadic fork : (fgh)x=(fx)g(hx)
  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 monadic hook : (fg)x=xf(gx)
  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