Functional Programming

h1. Haskell

"Haskell Cheatsheet":http://bxt.github.io/Ludus/haskell-cheatsheet/

h2. libs

* "concat":https://github.com/conal/concat ("z3cat":https://github.com/jwiegley/z3cat/blob/master/test/Main.hs || "smt example":https://github.com/conal/concat/blob/master/examples/src/ConCat/SMT.hs) — *"Compiling to categories":http://conal.net/papers/compiling-to-categories/* — compiler plugin for translating normal Haskell functions (on standard types) to SMT, etc.

* "SBV: SMT Based Verification":https://leventerkok.github.io/sbv/ — translates Haskell functions on custom symbolic types

* "refined":http://nikita-volkov.github.io/refined/ — refinement types <pre>type ProperFraction = Refined (And (Not (LessThan 0)) (Not (GreaterThan 1))) Double</pre>

* "hedgehog":https://github.com/hedgehogqa/haskell-hedgehog — random test gen (QuickCheck)

* "GHC.Stack":https://hackage.haskell.org/package/base-4.10.0.0/docs/GHC-Stack.html — can get code position for DSL

* "Data.Sequence":http://hackage.haskell.org/package/containers-0.6.0.1/docs/Data-Sequence.html — list with fast append on both sides

h2. exts

* "RebindableSyntax":https://ocharles.org.uk/guest-posts/2014-12-06-rebindable-syntax.html — overloading built-in operators / do notation

* "NullaryTypeClasses":https://ocharles.org.uk/posts/2014-12-10-nullary-type-classes.html — global implementation of one thing

h2. snippets

h3. Using Maybe Monad for checks

<pre>

{-# LANGUAGE LambdaCase, RecordWildCards #-}

import Data.Maybe (isJust, mapMaybe)

import Data.List (nub)

data Group = X25519 | Secp384

           deriving (Eq)

data KeyShareData = KeyShareClientHello [Group]

                  | KeyShareHelloRetryRequest Group

data Ext = SupportedGroups [Group]

         | KeyShares KeyShareData

check :: [Ext] -> [Ext] -> Bool

check eCH eHRR = isJust $ do

  sgCH <- exactlyOne $ mapMaybe (\case SupportedGroups gs -> Just gs; _ -> Nothing) eCH

  continueIf $ nub sgCH == sgCH -- no duplicates allowed

  ksCH <- (\case KeyShareClientHello gs -> Just gs; _ -> Nothing) =<<

    exactlyOne (mapMaybe (\case KeyShares ks -> Just ks; _ -> Nothing) eCH)

  ksHRR <- (\case KeyShareHelloRetryRequest g -> Just g; _ -> Nothing) =<<

    exactlyOne (mapMaybe (\case KeyShares ks -> Just ks; _ -> Nothing) eHRR)

  continueIf $ nub ksCH == ksCH -- no duplicates allowed

  continueIf $ ksHRR `elem` sgCH -- group must be supported

  continueIf $ ksHRR `notElem` ksCH -- key share must not have been already sent

exactlyOne :: [a] -> Maybe a

exactlyOne [x] = Just x

exactlyOne _ = Nothing

continueIf :: Bool -> Maybe ()

continueIf True = Just ()

continueIf False = Nothing

</pre>