STCK: Et stabelspråk implementert i F#
======================================
@_teodoran / Teodor Ande Elstad
  ___   _                 _
 / __| | |_   ____   __  | |__
 \__ \ |  _| / _  | / _| | / /
 |___/  \__| \__,_| \__| |_\_\

 ~~~~~~~~~~~ Baserte ~~~~~~~~~~~
  ___                 (o)   _
 / __|  _ __   _ _   ____  | |__
 \__ \ | '_ \ | '_| / _  | | / /
 |___/ | .__/ |_|   \__,_| |_\_\
       |_|



Litt historie
-------------
1968: Chuck Moore - Forth
2001: Manfred von Thun - Joy
2016: Stian Veum Møllersen - Ait



Stack-baserte programmeringsspråk
---------------------------------
* Alt er postfiks
* Ingen skikkelige variabler
* Hvordan funker det egentlig i praksis?




 Et stack-basert programmeringsspråk

  ____    _____    ____   _  __
 / ___|  |_   _|  / ___| | |/ /
 \___ \    | |   | |     | ' /
  ___) |   | |   | |___  | . \
 |____/    |_|    \____| |_|\_\

 (Beware of the Turing tar-pit)



STCK Demo #1
------------
* push og pop
* dup, 2dup, swap, rot
* tall, +, *, =, >=, <=



STCK Demo #2
------------
* anonyme stacker / quotations
* app
* church / unchurch



STCK Demo #3
------------
* bool [] [] ?
* [5 +] add-five #



Project Euler problem #2
------------------------
* Summer alle Fibonacci-tall under 10
* Svaret er 10



[2dup +] next-fib #

[next-fib dup 10 >=
    [fib-under-10]
    [.] ?] fib-under-10 #

[dup 2 % 0 =] is-even #

[dup 0 =] next-is-zero #

[swap is-even
    [+]
    [.] ?
    swap next-is-zero
        [.]
        [swap sum-if-even] ?] sum-if-even #

0 1 2 fib-under-10 sum-if-even



Esoterisk, ja gjett om! men...
------------------------------
* Lett å embedde => Bra for DSL
* Ingen variabler => Ingen problemer
* Begrensninger kan være en styrke!



names.Where(s => s.Length == 5)
     .OrderBy(s => s)
     .Select(s => s.ToUpper())



512 |> square |> toStr |> rev



ls | grep ".md" | rev



Konkatenative programmeringsspråk
---------------------------------
### Applikasjon

f(x) eller f x

### Komposisjon via Applikasjon

f(g(x)) _eller_ f ∘ g (x)

 x |> g |> f _eller_ x g f



Hvor funksjonelle er disse språkene?
------------------------------------
### sann / falsk

sann(a, b) = a
falsk(a, b) = b

### tall

0 f x = x
1 f x = f(x)
2 f x = f(f(x))



Litt om implementasjon av STCK i F#
-----------------------------------
* Stack-typen i Stck.fs
* Context-typen
* eval
* apply
* testing



  _   _                               (o)   ___
 | | | | __   __   ____     _ __     ____  |__ \
 | |_| | \ \ / /  / _  |   | '_ \   / _  |   / /
 |  _  |  \ V /  | (_| |   | | | | | (_| |  |_|
 |_| |_|   \_/    \__,_|   |_| |_|  \__,_|  (_)

         (Hva var poenget med dette)


Begrensede språk har fordeler
-----------------------------
* Færre ting som kan brukes feil
* Lett og embedde, DSL?


F# er gøy!
----------
* Nuff said


ctrl + end






         ____  ____  ____  ____
      s ||t ||||a ||||k ||||k ||
        ||__||||__||||__||||__||
        |/__\||/__\||/__\||/__\|
            ____  ____  ____
           ||f ||||o ||||r ||
           ||__||||__||||__||
           |/__\||/__\||/__\|
         ____  ____  ____  ____
        ||m ||||e ||||g ||||! ||
        ||__||||__||||__||||__||
        |/__\||/__\||/__\||/__\|