Funkcionální frontend - zkušenosti?

[Radek Miček]

Můžete si definovat vlastní vzory pro pattern matching.

Aha, takže něco jako guards v Erlangu, ale pojmenované a znovupoužitelné. To je dobrý, to se mi líbí.

Myslím, že to není úplně jako guards - F# má také guards a také pomocí when. Rozdíl je v tom, že active patterns mohou mít i výstup. Například

Kód: [Vybrat]

    /// Matches when a string starts with a sub-string wrapped using the
    /// opening and closing sub-string specified in the parameter.
    /// For example "[aa]bc" is wrapped in [ and ] pair. Returns the wrapped
    /// text together with the rest.
    let (|StartsWithWrapped|_|) (starts:string) (ends:string) (text:string) =
      if text.StartsWith(starts) then
        let id = text.IndexOf(ends, starts.Length)
        if id >= 0 then
          let wrapped = text.Substring(starts.Length, id - starts.Length)
          let rest = text.Substring(id + ends.Length, text.Length - id - ends.Length)
          Some(wrapped, rest)
        else None
      else None

Výstup je dvojice (wrapped, rest). Ukázka použití

Kód: [Vybrat]

    match "[Zkousime active](pattern)s" with
    | StartsWithWrapped "[" "]" (vHranatych, StartsWithWrapped "(" ")" (vKulatych, zbytek)) ->
        printfn "v hranatych '%s', v kulatych '%s', zbytek '%s'" vHranatych vKulatych zbytek
    | _ -> printfn "nic"

vypíše: v hranatych 'Zkousime active', v kulatych 'pattern', zbytek 's'

Pro zajímavost: v tom patternu můžu použít libovolnou fci? V Erlangu je to omezené jenom na některé jednoduché fce, aby se v rámci matchování neděla nějaká zvěrstva

Uvnitř active patternů i guardů jde používat libovolné funkce.

Polymorfní varianty dovolují napsat funkci, jenž zpracovává pouze zprávy Ok a | Zelena | Cervena (a když do ní zkusíte dát Modra nebo Err nebo něco jiného, tak to kompilátor označí za chybu).

Aha, takže můžu vybrat jenom některé varianty z různých typů? To je teda dost divočina A jaký typ se z toho pak inferuje, když je to částečně Result a částečně Color?

Bude se inferovat typ [< `Res of 'a | `Zelena | `Cervena]. Znak < říká, že funkce dovede zpracovat tyto 3 varianty nebo méně (do funkce lze dát např. i hodnotu typu [`Res of 'a | `Cervena]). Viz manuál OCamlu.

[Reklama]

[andy]

Jojo, v Haskellu na to jsou extensiony ViewPattern a PatternSynonyms. PatternSynonyms mají navíc tu vlastnost, že mohou být dvojsměrné (tzn. fungovat jako konstruktor). To použití zas tak časté není - ale v těch pár případech, kdy jsem to použil, to docela zvýšilo čitelnost.

[andy]

Jen pro zajímavost (proč mám rád haskell  ):

Kód: [Vybrat]

tsplit :: Char -> T.Text -> Maybe (T.Text, T.Text)
tsplit chr txt
  | T.null end = Nothing
  | otherwise = Just (start, T.drop 1 end)
  where
    (start, end) = T.break (== chr) txt

wrapped :: Char -> Char -> T.Text -> Maybe (T.Text, T.Text)
wrapped dstart dend txt
  | Just ("", cont') <- tsplit dstart txt,
    Just (inside, rest) <- tsplit dend cont' = Just (inside, rest)
  | otherwise = Nothing

pattern Hranate txt rest <- (wrapped '[' ']' -> Just (txt, rest))
pattern Kulate txt rest <- (wrapped '(' ')' -> Just (txt, rest))

match :: T.Text -> T.Text
match (Hranate vHranatych (Kulate vKulatych zbytek)) =
    "v hranatych " <> vHranatych <> ", v kulatych " <> vKulatych <> ", zbytek " <> zbytek
match _ = "nic"

main = print $ match "[Zkousime active](pattern)s"



[Radek Miček]

Jen pro zajímavost (proč mám rád haskell  ):

Drobný rozdíl je, že kód v F# dovoluje, aby „závorka“ byla libovolný řetězec - zatímco u kódu v Haskellu to musí být jeden znak.

[andy]

Drobný rozdíl je, že kód v F# dovoluje, aby „závorka“ byla libovolný řetězec - zatímco u kódu v Haskellu to musí být jeden znak.

Proč mám rád Haskell^2 včetně ukázky obousměrných Pattern Synonyms:

Kód: [Vybrat]

tsplit :: T.Text -> T.Text -> Maybe (T.Text, T.Text)
tsplit chr txt
  | T.null end = Nothing
  | otherwise = Just (start, T.drop (T.length chr) end)
  where
    (start, end) = T.breakOn chr txt

wrapped :: T.Text -> T.Text -> T.Text -> Maybe (T.Text, T.Text)
wrapped dstart dend txt
  | Just ("", cont') <- tsplit dstart txt = tsplit dend cont'
  | otherwise = Nothing

pattern Hranate txt rest <- (wrapped "[" "]" -> Just (txt, rest))
  where Hranate txt rest = "[" <> txt <> "]" <> rest
pattern Kulate txt rest <- (wrapped "(" ")" -> Just (txt, rest))
  where Kulate txt rest = "(" <> txt <> ")" <> rest

match :: T.Text -> T.Text
match (Hranate vHranatych (Kulate vKulatych zbytek)) =
    "v hranatych " <> vHranatych <> ", v kulatych " <> vKulatych <> ", zbytek " <> zbytek
match _ = "nic"

main = do
  print $ match "[Zkousime active](pattern)s"
  print $ Hranate "Zkousime active" (Kulate "pattern" "s")


[Reklama]

[Mirek Prýmek]

Myslím, že to není úplně jako guards - F# má také guards a také pomocí when. Rozdíl je v tom, že active patterns mohou mít i výstup. Například

Aha, chápu. No tak to už je úplná divočina Pěkně!

[Mirek Prýmek]

For record:

Tak jsem se trochu víc ponořil do Elmu, ze začátku to bylo trochu náročnější, než jsem si občerstvil haskellovský styl a pochopil, jak to vlastně mají celé vymyšlené, ale jakmile se to zlomilo, můžu říct, že jsem fakt nadšenej. Pro programátora je to jednoduché, přímočaré a jakmile jsem si napsal kostru (připojení na websockety, správné předávání zpráv komponentám a jeden widget), jsem schopnej nový widget vytvořit během chviličky, prakticky jenom přejmenováním a úpravou modelu a view.

Hodně se mi líbí, jak mají vymyšlenou komunikaci (signály, mailboxy, porty) - FRP je fajn, cítím se v něm skoro jako v Erlangu Líbí se mi možnost celkem bezproblémové komunikace s javascriptem (přes port, takže čistě) a mile mě překvapilo, že existuje nečistá funkce Debug.log, kterou se dají kdekoli v případě potřeby dělat ladící výpisy. Vypadá to, že autor je pragmatik a ne pure-fašista, což kvituju

Musím říct, že ve staticky typovaném frontendu se po těch letech s JS cítím jak Alenka v říši <div>ů - člověk přidá nějakou událost na tlačítku a kompilátor ho upozorní, že tuhle akci ještě v update funkci nezpracoval. Žádný chyby po nasazení, funguje pověstné haskellovské "pokud se to zkompiluje, tak to funguje"

Takže, pánové, díky moc za cennou konzultaci, rady a tipy. Zdá se, že habemus framework!

[xxar3s_______]

F# je moj oblubeny jazyk ale na dynamicke zalezitosti sa vôbec nehodi. F# ma silne typovanie a svet js je preane opacny. Existuje dokonca transpiler F# do js vola sa dunscript ale ako som uz hovoril f# si s js kniznicami nerozumie.

Clojure nepoznam ale nieco som zacul o frameworku ohm clojuristi jo dost chvalia.

Pre mna osobne bol najlepsou volbou cisty js neni to zas moc funkcionalne ale da sa v tom uz celkom obstojne programovat. Babel je dnes uz nevyhnutnost a k tomu webpack. react je perfektna kniznica mozem len odporucit. A k tomu immutable.js na pracu s kolekciami. V reacte je totiz dolezite aby state bol immutable co kolekcie jska nesplnaju.

[xxar3s_______]

Oprava Funscript.

Este doplnim ze preco vlastne nie f# na klienta. Na klientovi sa vsetko tvori on the fly a f# sa naopak mohutne spolieha na typy compile time. f# nema ani podporu duck typingu da sa tam sice doprogramovat pretazenim operatorov ? A ?<- Ale neni to ono. Nieco sa obchadza pomocou type providerov ale stale to nema na dynamicke typy.

[Mirek Prýmek]

F# je moj oblubeny jazyk ale na dynamicke zalezitosti sa vôbec nehodi. F# ma silne typovanie a svet js je preane opacny.

Úplně nerozumim tomu, proč by frontend měl být "dynamičtější" než zbytek aplikace. Od backendu dostává nějaká data, ta nějak zobrazuje a reaguje na události od uživatele. To není nic, na co by se statické typování nedalo použít, všechno je známo v době překladu.

Integrace s JS je problém, to je jasné. Elm na to jde pomocí portů, což mi zatím připadá dost elegantní přístup - port funguje tak, že má nějaký JS kód, který kooperuje s tím jiným JS, ale vrací přesně daný typ a do zbytku aplikace se to promítá jako stream událostí jednoho typu, takže se s tím pak už dá pracovat silně typovaně.

[noef]

Co ctu, tak FE vyvojari velkych aplikaci casto pokukuji po poradne typovanych i statickych jazycich. Proto treba dvojkovy Angular je primarne TypeScript vec.

S propojenim s okolnim JS pribude vetsinou krok navic, ale nebyva to nejaky zavratny problem. Zmineny TypeScript pouziva type definition a takova ScalaJS facades. Oboje funguje jako tenka vrstva pro "pridani" typů urcite JS knihovne. Zni to v podstate stejne, jako ty porty popisovane Mirkem.

[Radek Miček]

Oprava Funscript.

FunScript je o dost horší než WebSharper. Řadu konstrukcí z F# jako například třídy nebo rozhraní překládá FunScript špatně (programy přeložené do JS pak nefungují).

f# sa naopak mohutne spolieha na typy compile time.

Z mé zkušenosti (používám React) s tím žádný problém není - spíše naopak - díky tomu se jde hladce vyznat i ve složitějších aplikacích.