tacit programming : Point-free, Concatenatives & J

tacit programming : Point-free, Concatenatives & J

Transcript

1. tacit programming
   Point-free, Concatenatives & J
   

   View Slide

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

   View Slide

3. I'll talking about
   tacit programming
   

   View Slide

4. tacit?
   tacit : silent, unspoken
   

   View Slide

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

   View Slide

6. point-free style
   in Haskell
   

   View Slide

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

   View Slide

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

   View Slide

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

   View Slide

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

    View Slide

11. Let's do point-free style
    Compose functions.
    Don't think about values.
    

    View Slide

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

    View Slide

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

    View Slide

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.
    

    View Slide

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

    View Slide

16. point-free style is under
    combinatory logic
    

    View Slide

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

    View Slide

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.
    

    View Slide

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.
    

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

24. quotaion?
    

    View Slide

25. concatenative programming
    language
    is based on combinatory logic
    

    View Slide

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

    View Slide

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.
    

    View Slide

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.
    

    View Slide

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

    View Slide

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.
    

    View Slide

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

    View Slide

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.
    

    View Slide

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

    View Slide

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

    View Slide

35. J
    

    View Slide

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
    

    View Slide

37. Example 1 : add
    2+3
    5
    dyadic +
    plus 2 numbers.
    

    View Slide

38. Example 1 : add
    +/2 3
    5
    2 3
    is a vector.
    /
    is fold. So +/
    sums the vector.
    

    View Slide

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

    View Slide

40. Example 2 : average
    Evaluation flow.
    (+/ % #) 2 3
    (+/ 2 3) % (# 2 3) NB. monadic fork
    monadic fork : (fgh)x=(fx)g(hx)
    

    View Slide

41. Example 3 : factorial
    !9
    362880
    :)
    

    View Slide

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

    View Slide

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
    

    View Slide

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

    View Slide

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)
    

    View Slide

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
    

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide

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

    View Slide